From: Charles Manning Date: Wed, 3 Nov 2010 03:21:38 +0000 (+1300) Subject: Merge branch 'master' of ssh://www.aleph1.co.uk/home/aleph1/git/yaffs2 X-Git-Tag: linux-mainline-patchset-4~132 X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=commitdiff_plain;h=5409719091c79983abc45bcc3070bce6786c8278;hp=0577984f13993d243b05a5cebad48cc32e7f983a Merge branch 'master' of ssh://aleph1.co.uk/home/aleph1/git/yaffs2 --- diff --git a/Makefile b/Makefile index a6b5d14..1dbafc6 100644 --- a/Makefile +++ b/Makefile @@ -26,26 +26,26 @@ ifneq ($(KERNELRELEASE),) obj-m := $(YAFFS_O) - yaffs2-objs := yaffs_mtdif.o yaffs_mtdif2.o - yaffs2-objs += yaffs_mtdif1.o yaffs_packedtags1.o - yaffs2-objs += yaffs_ecc.o yaffs_vfs.o yaffs_guts.o + yaffs2-objs := yaffs_mtdif.o yaffs_mtdif2_single.o + yaffs2-objs += yaffs_mtdif1_single.o yaffs_packedtags1.o + yaffs2-objs += yaffs_ecc.o yaffs_vfs_single.o yaffs_guts.o yaffs2-objs += yaffs_packedtags2.o yaffs2-objs += yaffs_tagscompat.o yaffs_tagsvalidity.o yaffs2-objs += yaffs_checkptrw.o yaffs_nand.o yaffs2-objs += yaffs_checkptrw.o yaffs_nand.o yaffs_nameval.o - yaffs2-objs += yaffs_allocator.o yaffs_bitmap.o + yaffs2-objs += yaffs_allocator.o yaffs_bitmap.o yaffs_attribs.o yaffs2-objs += yaffs_yaffs1.o yaffs2-objs += yaffs_yaffs2.o yaffs2-objs += yaffs_verify.o - yaffs2multi-objs := yaffs_mtdif.o yaffs_mtdif2.o - yaffs2multi-objs += yaffs_mtdif1.o yaffs_packedtags1.o + yaffs2multi-objs := yaffs_mtdif.o yaffs_mtdif2_multi.o + yaffs2multi-objs += yaffs_mtdif1_multi.o yaffs_packedtags1.o yaffs2multi-objs += yaffs_ecc.o yaffs_vfs_multi.o yaffs_guts.o yaffs2multi-objs += yaffs_packedtags2.o yaffs2multi-objs += yaffs_tagscompat.o yaffs_tagsvalidity.o yaffs2multi-objs += yaffs_checkptrw.o yaffs_nand.o yaffs2multi-objs += yaffs_checkptrw.o yaffs_nand.o yaffs_nameval.o - yaffs2multi-objs += yaffs_allocator.o yaffs_bitmap.o + yaffs2multi-objs += yaffs_allocator.o yaffs_bitmap.o yaffs_attribs.o yaffs2multi-objs += yaffs_yaffs1.o yaffs2multi-objs += yaffs_yaffs2.o yaffs2multi-objs += yaffs_verify.o diff --git a/Makefile.kernel b/Makefile.kernel index fbdbd4a..e63a28a 100644 --- a/Makefile.kernel +++ b/Makefile.kernel @@ -4,11 +4,11 @@ obj-$(CONFIG_YAFFS_FS) += yaffs.o -yaffs-y := yaffs_ecc.o yaffs_vfs_glue.o yaffs_guts.o yaffs_checkptrw.o +yaffs-y := yaffs_ecc.o yaffs_vfs.o yaffs_guts.o yaffs_checkptrw.o yaffs-y += yaffs_packedtags1.o yaffs_packedtags2.o yaffs_nand.o yaffs-y += yaffs_tagscompat.o yaffs_tagsvalidity.o yaffs-y += yaffs_mtdif.o yaffs_mtdif1.o yaffs_mtdif2.o -yaffs-y += yaffs_nameval.o +yaffs-y += yaffs_nameval.o yaffs_attribs.o yaffs-y += yaffs_allocator.o yaffs-y += yaffs_yaffs1.o yaffs-y += yaffs_yaffs2.o diff --git a/devextras.h b/devextras.h deleted file mode 100644 index ce30c82..0000000 --- a/devextras.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2010 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License version 2.1 as - * published by the Free Software Foundation. - * - * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. - */ - -/* - * This file is just holds extra declarations of macros that would normally - * be providesd in the Linux kernel. These macros have been written from - * scratch but are functionally equivalent to the Linux ones. - * - */ - -#ifndef __EXTRAS_H__ -#define __EXTRAS_H__ - - -#include "yportenv.h" - -#if !(defined __KERNEL__) - -/* Definition of types */ -typedef unsigned char __u8; -typedef unsigned short __u16; -typedef unsigned __u32; - -#endif - - -#if !(defined __KERNEL__) - - -#ifndef WIN32 -#include -#endif - - -#ifdef CONFIG_YAFFS_PROVIDE_DEFS -/* File types */ - - -#define DT_UNKNOWN 0 -#define DT_FIFO 1 -#define DT_CHR 2 -#define DT_DIR 4 -#define DT_BLK 6 -#define DT_REG 8 -#define DT_LNK 10 -#define DT_SOCK 12 -#define DT_WHT 14 - - -#ifndef WIN32 -#include -#endif - -/* - * Attribute flags. These should be or-ed together to figure out what - * has been changed! - */ -#define ATTR_MODE 1 -#define ATTR_UID 2 -#define ATTR_GID 4 -#define ATTR_SIZE 8 -#define ATTR_ATIME 16 -#define ATTR_MTIME 32 -#define ATTR_CTIME 64 - -struct iattr { - unsigned int ia_valid; - unsigned ia_mode; - unsigned ia_uid; - unsigned ia_gid; - unsigned ia_size; - unsigned ia_atime; - unsigned ia_mtime; - unsigned ia_ctime; - unsigned int ia_attr_flags; -}; - -#endif - -#else - -#include -#include -#include - -#endif - - -#endif diff --git a/direct/basic-test/Makefile b/direct/basic-test/Makefile index 4054ed1..7847528 100644 --- a/direct/basic-test/Makefile +++ b/direct/basic-test/Makefile @@ -34,8 +34,8 @@ COMMONTESTOBJS = yaffscfg2k.o yaffs_ecc.o yaffs_fileem.o yaffs_fileem2k.o yaffsf yaffs_packedtags1.o yaffs_ramdisk.o yaffs_ramem2k.o \ yaffs_tagscompat.o yaffs_packedtags2.o yaffs_tagsvalidity.o yaffs_nand.o \ yaffs_checkptrw.o yaffs_qsort.o\ - yaffs_nameval.o \ - yaffs_norif1.o ynorsim.o nor_stress.o yaffs_fsx.o \ + yaffs_nameval.o yaffs_attribs.o \ + yaffs_norif1.o ynorsim.o \ yaffs_allocator.o \ yaffs_bitmap.o \ yaffs_yaffs1.o \ @@ -44,17 +44,13 @@ COMMONTESTOBJS = yaffscfg2k.o yaffs_ecc.o yaffs_fileem.o yaffs_fileem2k.o yaffsf # yaffs_checkptrwtest.o\ -YAFFSTESTOBJS = $(COMMONTESTOBJS) yaffs_test.o - -ALLOBJS = $(sort $(YAFFSTESTOBJS)) - -YAFFSSYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yportenv.h yaffs_tagscompat.c yaffs_tagscompat.h \ +YAFFSSYMLINKS = yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yaffs_tagscompat.c yaffs_tagscompat.h \ yaffs_packedtags1.c yaffs_packedtags1.h yaffs_packedtags2.c yaffs_packedtags2.h \ - yaffs_nand.c yaffs_nand.h yaffs_getblockinfo.h yaffs_list.h \ + yaffs_nand.c yaffs_nand.h yaffs_getblockinfo.h \ yaffs_tagsvalidity.c yaffs_tagsvalidity.h yaffs_checkptrw.h yaffs_checkptrw.c \ yaffs_nameval.c yaffs_nameval.h \ - yaffs_qsort.h yaffs_trace.h \ + yaffs_trace.h yaffs_attribs.h \ yaffs_allocator.c yaffs_allocator.h \ yaffs_yaffs1.c yaffs_yaffs1.h \ yaffs_yaffs2.c yaffs_yaffs2.h \ @@ -63,8 +59,8 @@ YAFFSSYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yp YAFFSDIRECTSYMLINKS = yaffsfs.c yaffs_flashif.h yaffs_flashif2.h\ yaffsfs.h yaffs_malloc.h ydirectenv.h \ - yaffs_flashif.c yaffscfg.h \ - yaffs_qsort.c \ + yaffs_flashif.c yaffscfg.h yaffs_list.h \ + yaffs_qsort.c yportenv.h yaffs_attribs.c \ yaffs_nandif.c yaffs_nandif.h yaffs_nandemul2k.h @@ -72,21 +68,6 @@ YAFFSDIRECTSYMLINKS = yaffsfs.c yaffs_flashif.h yaffs_flashif2.h\ SYMLINKS = $(YAFFSSYMLINKS) $(YAFFSDIRECTSYMLINKS) - - -COMMONTESTOBJS = yaffsnewcfg.o yramsim.o \ - yaffsfs.o yaffs_guts.o yaffs_ecc.o yaffs_nandif.o \ - yaffs_packedtags1.o yaffs_ramdisk.o yaffs_ramem2k.o \ - yaffs_tagscompat.o yaffs_packedtags2.o yaffs_tagsvalidity.o yaffs_nand.o \ - yaffs_checkptrw.o yaffs_qsort.o\ - yaffs_nameval.o \ - yaffs_norif1.o ynorsim.o \ - yaffs_allocator.o yaffs_yaffs1.o \ - yaffs_yaffs2.o \ - yaffs_bitmap.o yaffs_verify.o - -# yaffs_checkptrwtest.o\ - DIRECTTESTOBJS = $(COMMONTESTOBJS) dtest.o BOOTTESTOBJS = bootldtst.o yboot.o yaffs_fileem.o nand_ecc.o diff --git a/direct/basic-test/dtest.c b/direct/basic-test/dtest.c index 691ffe2..e6a0a14 100644 --- a/direct/basic-test/dtest.c +++ b/direct/basic-test/dtest.c @@ -2516,7 +2516,7 @@ static void print_xattrib_val(const char *path, const char *name) n = yaffs_getxattr(path,name,buffer,sizeof(buffer)); if(n >= 0){ - __u8 *b = (__u8 *)buffer; + u8 *b = (u8 *)buffer; printf("%d bytes:",n); if(n > 10) @@ -2642,7 +2642,7 @@ void big_xattr_test(const char *mountpt) } -void dump_dev_stats(yaffs_dev_t *dev, const char * str) +void dump_dev_stats(struct yaffs_dev *dev, const char * str) { printf("%s\n",str); printf( "space free %d erased %d " @@ -2658,7 +2658,7 @@ void test_flash_traffic(const char *mountpt) char name0[100]; char name1[100]; int i; - yaffs_dev_t *dev; + struct yaffs_dev *dev; yaffs_trace_mask = 0; diff --git a/direct/basic-test/yaffs_fileem.c b/direct/basic-test/yaffs_fileem.c index 419b16f..702acbe 100644 --- a/direct/basic-test/yaffs_fileem.c +++ b/direct/basic-test/yaffs_fileem.c @@ -25,8 +25,6 @@ const char *yaffs_flashif_c_version = "$Id: yaffs_fileem.c,v 1.7 2010-02-18 01:1 #include "yaffs_flashif.h" #include "yaffs_guts.h" -#include "devextras.h" - #include #include #include @@ -43,7 +41,7 @@ const char *yaffs_flashif_c_version = "$Id: yaffs_fileem.c,v 1.7 2010-02-18 01:1 typedef struct { - __u8 data[528]; // Data + spare + u8 data[528]; // Data + spare } yflash_Page; typedef struct @@ -62,7 +60,7 @@ typedef struct static yflash_Device filedisk; -static int CheckInit(yaffs_dev_t *dev) +static int CheckInit(struct yaffs_dev *dev) { static int initialised = 0; @@ -118,7 +116,7 @@ static int CheckInit(yaffs_dev_t *dev) return 1; } -int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare) +int yflash_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare) { int written; @@ -148,7 +146,7 @@ int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, co } -int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare) +int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare) { int nread; @@ -178,7 +176,7 @@ int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ } -int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) +int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber) { int i; @@ -208,7 +206,7 @@ int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) } -int yflash_InitialiseNAND(yaffs_dev_t *dev) +int yflash_InitialiseNAND(struct yaffs_dev *dev) { return YAFFS_OK; diff --git a/direct/basic-test/yaffs_fileem2k.c b/direct/basic-test/yaffs_fileem2k.c index 367003e..06e41e5 100644 --- a/direct/basic-test/yaffs_fileem2k.c +++ b/direct/basic-test/yaffs_fileem2k.c @@ -24,23 +24,23 @@ const char *yaffs_flashif2_c_version = "$Id: yaffs_fileem2k.c,v 1.24 2010-02-18 #include "yaffs_flashif2.h" #include "yaffs_guts.h" -#include "devextras.h" +#include "yaffs_fileem2k.h" +#include "yaffs_packedtags2.h" +#include "yaffs_tagsvalidity.h" + #include #include #include #include -#include "yaffs_fileem2k.h" -#include "yaffs_packedtags2.h" - #define REPORT_ERROR 0 typedef struct { - __u8 data[PAGE_SIZE]; // Data + spare + u8 data[PAGE_SIZE]; // Data + spare } yflash_Page; typedef struct @@ -66,7 +66,6 @@ int yaffs_test_partial_write = 0; extern int random_seed; extern int simulate_power_failure; -static int initialised = 0; static int remaining_ops; static int nops_so_far; @@ -93,7 +92,7 @@ static void yflash2_MaybePowerFail(unsigned int nand_chunk, int failPoint) -static __u8 localBuffer[PAGE_SIZE]; +static u8 localBuffer[PAGE_SIZE]; static char *NToName(char *buf,int n) { @@ -171,7 +170,7 @@ int yflash2_GetNumberOfBlocks(void) return filedisk.nBlocks; } -int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags) +int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags) { int written; int pos; @@ -180,15 +179,15 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 int nRead; int error; - T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %x tags %x" TENDSTR),nand_chunk,(unsigned)data, (unsigned)tags)); + T(YAFFS_TRACE_MTD,(TSTR("write chunk %d data %p tags %p" TENDSTR),nand_chunk, data, tags)); CheckInit(); if(dev->param.inband_tags){ - yaffs_packed_tags2_tags_only * pt2tp; - pt2tp = (yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; + struct yaffs_packed_tags2_tags_only * pt2tp; + pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; yaffs_pack_tags2_tags_only(pt2tp,tags); pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; @@ -255,14 +254,14 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 if( 0 && dev->param.is_yaffs2) { - written = write(h,tags,sizeof(yaffs_ext_tags)); - if(written != sizeof(yaffs_ext_tags)) return YAFFS_FAIL; + written = write(h,tags,sizeof(struct yaffs_ext_tags)); + if(written != sizeof(struct yaffs_ext_tags)) return YAFFS_FAIL; } else { - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; yaffs_pack_tags2(&pt,tags, !dev->param.no_tags_ecc); - __u8 * ptab = (__u8 *)&pt; + u8 * ptab = (u8 *)&pt; nRead = read(h,localBuffer,sizeof(pt)); for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){ @@ -333,14 +332,14 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 if( 0 && dev->param.is_yaffs2) { - written = write(h,tags,sizeof(yaffs_ext_tags)); - if(written != sizeof(yaffs_ext_tags)) return YAFFS_FAIL; + written = write(h,tags,sizeof(struct yaffs_ext_tags)); + if(written != sizeof(struct yaffs_ext_tags)) return YAFFS_FAIL; } else { - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; yaffs_pack_tags2(&pt,tags,!dev->param.no_tags_ecc); - __u8 * ptab = (__u8 *)&pt; + u8 * ptab = (u8 *)&pt; nRead = read(h,localBuffer,sizeof(pt)); for(i = error = 0; REPORT_ERROR && i < sizeof(pt) && !error; i++){ @@ -371,7 +370,7 @@ int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 } -int yaffs_check_all_ff(const __u8 *ptr, int n) +int yaffs_check_all_ff(const u8 *ptr, int n) { while(n) { @@ -388,7 +387,7 @@ static int fail320 = 1; static int failRead10 = 2; -int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags) +int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags) { int nread; int pos; @@ -397,7 +396,7 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *dat int retval = YAFFS_OK; int nRead; - T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %x tags %x" TENDSTR),nand_chunk,(unsigned)data, (unsigned)tags)); + T(YAFFS_TRACE_MTD,(TSTR("read chunk %d data %p tags %p" TENDSTR),nand_chunk, data, tags)); CheckInit(); @@ -412,8 +411,8 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *dat } - yaffs_packed_tags2_tags_only * pt2tp; - pt2tp = (yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; + struct yaffs_packed_tags2_tags_only * pt2tp; + pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; pos = (nand_chunk % (PAGES_PER_BLOCK * BLOCKS_PER_HANDLE)) * PAGE_SIZE; @@ -458,10 +457,10 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *dat if(0 && dev->param.is_yaffs2) { - nread= read(h,tags,sizeof(yaffs_ext_tags)); - if(nread != sizeof(yaffs_ext_tags)) + nread= read(h,tags,sizeof(struct yaffs_ext_tags)); + if(nread != sizeof(struct yaffs_ext_tags)) retval = YAFFS_FAIL; - if(yaffs_check_all_ff((__u8 *)tags,sizeof(yaffs_ext_tags))) + if(yaffs_check_all_ff((u8 *)tags,sizeof(struct yaffs_ext_tags))) { yaffs_init_tags(tags); } @@ -472,7 +471,7 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *dat } else { - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; nread= read(h,&pt,sizeof(pt)); yaffs_unpack_tags2(tags,&pt, !dev->param.no_tags_ecc); #ifdef SIMULATE_FAILURES @@ -508,12 +507,12 @@ int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *dat } -int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) +int yflash2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no) { int written; int h; - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; CheckInit(); @@ -529,7 +528,7 @@ int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) } -int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) +int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber) { int i; @@ -550,7 +549,7 @@ int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) else { - __u8 pg[PAGE_SIZE]; + u8 pg[PAGE_SIZE]; int syz = PAGE_SIZE; int pos; @@ -570,7 +569,7 @@ int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) } -int yflash2_InitialiseNAND(yaffs_dev_t *dev) +int yflash2_InitialiseNAND(struct yaffs_dev *dev) { CheckInit(); @@ -580,9 +579,9 @@ int yflash2_InitialiseNAND(yaffs_dev_t *dev) -int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number) +int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number) { - yaffs_ext_tags tags; + struct yaffs_ext_tags tags; int chunkNo; *seq_number = 0; diff --git a/direct/basic-test/yaffs_norif1.c b/direct/basic-test/yaffs_norif1.c index 5657c00..7be6295 100644 --- a/direct/basic-test/yaffs_norif1.c +++ b/direct/basic-test/yaffs_norif1.c @@ -45,8 +45,6 @@ const char *yaffs_norif1_c_version = "$Id: yaffs_norif1.c,v 1.6 2010-02-18 01:18 #include "yaffs_flashif.h" #include "yaffs_guts.h" -#include "devextras.h" - #define SPARE_BYTES_PER_CHUNK 16 #define M18_SKIP 16 #define PROG_REGION_SIZE 1024 @@ -88,58 +86,58 @@ const char *yaffs_norif1_c_version = "$Id: yaffs_norif1.c,v 1.6 2010-02-18 01:18 #define DEVICE_BASE (32 * 1024 * 1024) #endif -__u32 *Block2Addr(yaffs_dev_t *dev, int blockNumber) +u32 *Block2Addr(struct yaffs_dev *dev, int blockNumber) { - __u32 addr; + u32 addr; dev=dev; - addr = (__u32) DEVICE_BASE; + addr = (u32) DEVICE_BASE; addr += blockNumber * BLOCK_SIZE_IN_BYTES; - return (__u32 *) addr; + return (u32 *) addr; } -__u32 *Block2FormatAddr(yaffs_dev_t *dev,int blockNumber) +u32 *Block2FormatAddr(struct yaffs_dev *dev,int blockNumber) { - __u32 addr; + u32 addr; - addr = (__u32) Block2Addr(dev,blockNumber); + addr = (u32) Block2Addr(dev,blockNumber); addr += FORMAT_OFFSET; - return (__u32 *)addr; + return (u32 *)addr; } -__u32 *Chunk2DataAddr(yaffs_dev_t *dev,int chunk_id) +u32 *Chunk2DataAddr(struct yaffs_dev *dev,int chunk_id) { unsigned block; unsigned chunkInBlock; - __u32 addr; + u32 addr; block = chunk_id/dev->param.chunks_per_block; chunkInBlock = chunk_id % dev->param.chunks_per_block; - addr = (__u32) Block2Addr(dev,block); + addr = (u32) Block2Addr(dev,block); addr += chunkInBlock * DATA_BYTES_PER_CHUNK; - return (__u32 *)addr; + return (u32 *)addr; } -__u32 *Chunk2SpareAddr(yaffs_dev_t *dev,int chunk_id) +u32 *Chunk2SpareAddr(struct yaffs_dev *dev,int chunk_id) { unsigned block; unsigned chunkInBlock; - __u32 addr; + u32 addr; block = chunk_id/dev->param.chunks_per_block; chunkInBlock = chunk_id % dev->param.chunks_per_block; - addr = (__u32) Block2Addr(dev,block); + addr = (u32) Block2Addr(dev,block); addr += SPARE_AREA_OFFSET; addr += chunkInBlock * (SPARE_BYTES_PER_CHUNK + M18_SKIP); - return (__u32 *)addr; + return (u32 *)addr; } -void ynorif1_AndBytes(__u8*target, const __u8 *src, int nbytes) +void ynorif1_AndBytes(u8*target, const u8 *src, int nbytes) { while(nbytes > 0){ *target &= *src; @@ -149,12 +147,12 @@ void ynorif1_AndBytes(__u8*target, const __u8 *src, int nbytes) } } -int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare) +int ynorif1_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare) { - __u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk); - __u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk); + u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk); + u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk); - yaffs_spare tmpSpare; + struct yaffs_spare tmpSpare; /* We should only be getting called for one of 3 reasons: * Writing a chunk: data and spare will not be NULL @@ -162,7 +160,7 @@ int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, c * Writing a bad block marker: data will be NULL, spare not NULL */ - if(sizeof(yaffs_spare) != 16) + if(sizeof(struct yaffs_spare) != 16) YBUG(); if(data && spare) @@ -172,30 +170,30 @@ int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, c /* Write a pre-marker */ memset(&tmpSpare,0xff,sizeof(tmpSpare)); tmpSpare.page_status = YNOR_PREMARKER; - ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_spare)/4); + ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(struct yaffs_spare)/4); /* Write the data */ - ynorif1_FlashWrite32(dataAddr,(__u32 *)data,dev->param.total_bytes_per_chunk / 4); + ynorif1_FlashWrite32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / 4); - memcpy(&tmpSpare,spare,sizeof(yaffs_spare)); + memcpy(&tmpSpare,spare,sizeof(struct yaffs_spare)); /* Write the real tags, but override the premarker*/ tmpSpare.page_status = YNOR_PREMARKER; - ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(yaffs_spare)/4); + ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(struct yaffs_spare)/4); /* Write a post-marker */ tmpSpare.page_status = YNOR_POSTMARKER; - ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,sizeof(tmpSpare)/4); + ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,sizeof(tmpSpare)/4); } else if(spare){ /* This has to be a read-modify-write operation to handle NOR-ness */ - ynorif1_FlashRead32(spareAddr,(__u32 *)&tmpSpare,16/ 4); + ynorif1_FlashRead32(spareAddr,(u32 *)&tmpSpare,16/ 4); - ynorif1_AndBytes((__u8 *)&tmpSpare,(__u8 *)spare,sizeof(yaffs_spare)); + ynorif1_AndBytes((u8 *)&tmpSpare,(u8 *)spare,sizeof(struct yaffs_spare)); - ynorif1_FlashWrite32(spareAddr,(__u32 *)&tmpSpare,16/ 4); + ynorif1_FlashWrite32(spareAddr,(u32 *)&tmpSpare,16/ 4); } else { YBUG(); @@ -206,20 +204,20 @@ int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, c } -int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare) +int ynorif1_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare) { - __u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk); - __u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk); + u32 *dataAddr = Chunk2DataAddr(dev,nand_chunk); + u32 *spareAddr = Chunk2SpareAddr(dev,nand_chunk); if(data) { - ynorif1_FlashRead32(dataAddr,(__u32 *)data,dev->param.total_bytes_per_chunk / 4); + ynorif1_FlashRead32(dataAddr,(u32 *)data,dev->param.total_bytes_per_chunk / 4); } if(spare) { - ynorif1_FlashRead32(spareAddr,(__u32 *)spare,16/ 4); + ynorif1_FlashRead32(spareAddr,(u32 *)spare,16/ 4); /* If the page status is YNOR_POSTMARKER then it was written properly * so change that to 0xFF so that the rest of yaffs is happy. @@ -236,11 +234,11 @@ int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs } -static int ynorif1_FormatBlock(yaffs_dev_t *dev, int blockNumber) +static int ynorif1_FormatBlock(struct yaffs_dev *dev, int blockNumber) { - __u32 *blockAddr = Block2Addr(dev,blockNumber); - __u32 *formatAddr = Block2FormatAddr(dev,blockNumber); - __u32 formatValue = FORMAT_VALUE; + u32 *blockAddr = Block2Addr(dev,blockNumber); + u32 *formatAddr = Block2FormatAddr(dev,blockNumber); + u32 formatValue = FORMAT_VALUE; ynorif1_FlashEraseBlock(blockAddr); ynorif1_FlashWrite32(formatAddr,&formatValue,1); @@ -248,20 +246,20 @@ static int ynorif1_FormatBlock(yaffs_dev_t *dev, int blockNumber) return YAFFS_OK; } -static int ynorif1_UnformatBlock(yaffs_dev_t *dev, int blockNumber) +static int ynorif1_UnformatBlock(struct yaffs_dev *dev, int blockNumber) { - __u32 *formatAddr = Block2FormatAddr(dev,blockNumber); - __u32 formatValue = 0; + u32 *formatAddr = Block2FormatAddr(dev,blockNumber); + u32 formatValue = 0; ynorif1_FlashWrite32(formatAddr,&formatValue,1); return YAFFS_OK; } -static int ynorif1_IsBlockFormatted(yaffs_dev_t *dev, int blockNumber) +static int ynorif1_IsBlockFormatted(struct yaffs_dev *dev, int blockNumber) { - __u32 *formatAddr = Block2FormatAddr(dev,blockNumber); - __u32 formatValue; + u32 *formatAddr = Block2FormatAddr(dev,blockNumber); + u32 formatValue; ynorif1_FlashRead32(formatAddr,&formatValue,1); @@ -269,7 +267,7 @@ static int ynorif1_IsBlockFormatted(yaffs_dev_t *dev, int blockNumber) return (formatValue == FORMAT_VALUE); } -int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) +int ynorif1_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber) { if(blockNumber < 0 || blockNumber >= BLOCKS_IN_DEVICE) @@ -286,7 +284,7 @@ int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) } -int ynorif1_InitialiseNAND(yaffs_dev_t *dev) +int ynorif1_InitialiseNAND(struct yaffs_dev *dev) { int i; @@ -300,7 +298,7 @@ int ynorif1_InitialiseNAND(yaffs_dev_t *dev) return YAFFS_OK; } -int ynorif1_Deinitialise_flash_fn(yaffs_dev_t *dev) +int ynorif1_Deinitialise_flash_fn(struct yaffs_dev *dev) { dev=dev; ynorif1_FlashDeinit(); diff --git a/direct/basic-test/yaffs_norif1.h b/direct/basic-test/yaffs_norif1.h index ac78423..71cb51f 100644 --- a/direct/basic-test/yaffs_norif1.h +++ b/direct/basic-test/yaffs_norif1.h @@ -19,11 +19,11 @@ #include "yaffs_guts.h" -int ynorif1_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare); -int ynorif1_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare); -int ynorif1_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber); -int ynorif1_InitialiseNAND(yaffs_dev_t *dev); -int ynorif1_Deinitialise_flash_fn(yaffs_dev_t *dev); +int ynorif1_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare); +int ynorif1_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare); +int ynorif1_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber); +int ynorif1_InitialiseNAND(struct yaffs_dev *dev); +int ynorif1_Deinitialise_flash_fn(struct yaffs_dev *dev); #endif diff --git a/direct/basic-test/yaffs_ramdisk.c b/direct/basic-test/yaffs_ramdisk.c index 9834bb2..babddde 100644 --- a/direct/basic-test/yaffs_ramdisk.c +++ b/direct/basic-test/yaffs_ramdisk.c @@ -26,7 +26,6 @@ const char *yaffs_ramdisk_c_version = "$Id: yaffs_ramdisk.c,v 1.6 2010-01-11 04: #include "yaffs_ramdisk.h" #include "yaffs_guts.h" -#include "devextras.h" #include "yaffs_packedtags1.h" @@ -42,7 +41,7 @@ const char *yaffs_ramdisk_c_version = "$Id: yaffs_ramdisk.c,v 1.6 2010-01-11 04: typedef struct { - __u8 data[528]; // Data + spare + u8 data[528]; // Data + spare } yramdisk_page; typedef struct @@ -61,7 +60,7 @@ typedef struct static yramdisk_device ramdisk; -static int CheckInit(yaffs_dev_t *dev) +static int CheckInit(struct yaffs_dev *dev) { static int initialised = 0; @@ -119,7 +118,7 @@ static int CheckInit(yaffs_dev_t *dev) return 1; } -int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags) +int yramdisk_wr_chunk(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags) { int blk; int pg; @@ -139,7 +138,7 @@ int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const ya if(tags) { - yaffs_packed_tags1 pt; + struct yaffs_packed_tags1 pt; yaffs_pack_tags1(&pt,tags); memcpy(&ramdisk.block[blk]->page[pg].data[512],&pt,sizeof(pt)); @@ -150,7 +149,7 @@ int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const ya } -int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags) +int yramdisk_rd_chunk(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags) { int blk; int pg; @@ -170,7 +169,7 @@ int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tag if(tags) { - yaffs_packed_tags1 pt; + struct yaffs_packed_tags1 pt; memcpy(&pt,&ramdisk.block[blk]->page[pg].data[512],sizeof(pt)); yaffs_unpack_tags1(tags,&pt); @@ -181,7 +180,7 @@ int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tag } -int yramdisk_check_chunk_erased(yaffs_dev_t *dev,int nand_chunk) +int yramdisk_check_chunk_erased(struct yaffs_dev *dev,int nand_chunk) { int blk; int pg; @@ -206,7 +205,7 @@ int yramdisk_check_chunk_erased(yaffs_dev_t *dev,int nand_chunk) } -int yramdisk_erase(yaffs_dev_t *dev, int blockNumber) +int yramdisk_erase(struct yaffs_dev *dev, int blockNumber) { CheckInit(dev); @@ -224,7 +223,7 @@ int yramdisk_erase(yaffs_dev_t *dev, int blockNumber) } -int yramdisk_initialise(yaffs_dev_t *dev) +int yramdisk_initialise(struct yaffs_dev *dev) { //dev->use_nand_ecc = 1; // force on use_nand_ecc which gets faked. // This saves us doing ECC checks. diff --git a/direct/basic-test/yaffs_ramdisk.h b/direct/basic-test/yaffs_ramdisk.h index c250bcc..1749c58 100644 --- a/direct/basic-test/yaffs_ramdisk.h +++ b/direct/basic-test/yaffs_ramdisk.h @@ -22,10 +22,10 @@ #include "yaffs_guts.h" -int yramdisk_erase(yaffs_dev_t *dev, int blockNumber); -int yramdisk_wr_chunk(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags); -int yramdisk_rd_chunk(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags); -int yramdisk_initialise(yaffs_dev_t *dev); -int yramdisk_mark_block_bad(yaffs_dev_t *dev,int blockNumber); -int yramdisk_query_block(yaffs_dev_t *dev, int block_no, yaffs_block_state_t *state, int *seq_number); +int yramdisk_erase(struct yaffs_dev *dev, int blockNumber); +int yramdisk_wr_chunk(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags); +int yramdisk_rd_chunk(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags); +int yramdisk_initialise(struct yaffs_dev *dev); +int yramdisk_mark_block_bad(struct yaffs_dev *dev,int blockNumber); +int yramdisk_query_block(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, int *seq_number); #endif diff --git a/direct/basic-test/yaffs_ramem2k.c b/direct/basic-test/yaffs_ramem2k.c index 1a9765d..7f88b7c 100644 --- a/direct/basic-test/yaffs_ramem2k.c +++ b/direct/basic-test/yaffs_ramem2k.c @@ -31,7 +31,6 @@ const char *yaffs_ramem2k_c_version = "$Id: yaffs_ramem2k.c,v 1.8 2010-02-18 01: #include "yaffs_nandemul2k.h" #include "yaffs_guts.h" -#include "devextras.h" #include "yaffs_packedtags2.h" @@ -54,7 +53,7 @@ const char *yaffs_ramem2k_c_version = "$Id: yaffs_ramem2k.c,v 1.8 2010-02-18 01: typedef struct { - __u8 data[PAGE_TOTAL_SIZE]; // Data + spare + u8 data[PAGE_TOTAL_SIZE]; // Data + spare int empty; // is this empty? } nandemul_Page; @@ -190,13 +189,13 @@ static int CheckInit(void) return 1; } -int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags) +int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags) { int blk; int pg; int i; - __u8 *x; + u8 *x; blk = nand_chunk/PAGES_PER_BLOCK; @@ -220,7 +219,7 @@ int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __ { x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE]; - yaffs_pack_tags2((yaffs_packed_tags2 *)x,tags, !dev->param.no_tags_ecc); + yaffs_pack_tags2((struct yaffs_packed_tags2 *)x,tags, !dev->param.no_tags_ecc); } @@ -233,12 +232,12 @@ int nandemul2k_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __ } -int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags) +int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags) { int blk; int pg; - __u8 *x; + u8 *x; @@ -256,14 +255,14 @@ int nandemul2k_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 * { x = &ned.block[blk]->page[pg]->data[PAGE_DATA_SIZE]; - yaffs_unpack_tags2(tags,(yaffs_packed_tags2 *)x, !dev->param.no_tags_ecc); + yaffs_unpack_tags2(tags,(struct yaffs_packed_tags2 *)x, !dev->param.no_tags_ecc); } return YAFFS_OK; } -static int nandemul2k_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk) +static int nandemul2k_CheckChunkErased(struct yaffs_dev *dev,int nand_chunk) { int blk; int pg; @@ -287,7 +286,7 @@ static int nandemul2k_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk) } -int nandemul2k_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) +int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber) { @@ -307,29 +306,29 @@ int nandemul2k_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) return YAFFS_OK; } -int nandemul2k_InitialiseNAND(yaffs_dev_t *dev) +int nandemul2k_InitialiseNAND(struct yaffs_dev *dev) { CheckInit(); return YAFFS_OK; } -int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) +int nandemul2k_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no) { - __u8 *x; + u8 *x; x = &ned.block[block_no]->page[0]->data[PAGE_DATA_SIZE]; - memset(x,0,sizeof(yaffs_packed_tags2)); + memset(x,0,sizeof(struct yaffs_packed_tags2)); return YAFFS_OK; } -int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number) +int nandemul2k_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number) { - yaffs_ext_tags tags; + struct yaffs_ext_tags tags; int chunkNo; *seq_number = 0; diff --git a/direct/basic-test/yaffscfg.c b/direct/basic-test/yaffscfg.c index 590cb87..ce86587 100644 --- a/direct/basic-test/yaffscfg.c +++ b/direct/basic-test/yaffscfg.c @@ -42,7 +42,7 @@ void yaffsfs_Unlock(void) { } -__u32 yaffsfs_CurrentTime(void) +u32 yaffsfs_CurrentTime(void) { return 0; } @@ -67,16 +67,16 @@ void yaffsfs_LocalInitialisation(void) // /boot 2MB boot disk (flash) // /flash 14MB flash disk (flash) // NB Though /boot and /flash occupy the same physical device they -// are still disticnt "yaffs_dev_ts. You may think of these as "partitions" +// are still disticnt "struct yaffs_devs. You may think of these as "partitions" // using non-overlapping areas in the same device. // #include "yaffs_ramdisk.h" #include "yaffs_flashif.h" -static yaffs_dev_t ramDev; -static yaffs_dev_t bootDev; -static yaffs_dev_t flashDev; +static struct yaffs_dev ramDev; +static struct yaffs_dev bootDev; +static struct yaffs_dev flashDev; static yaffsfs_DeviceConfiguration yaffsfs_config[] = { diff --git a/direct/basic-test/yaffscfg2k.c b/direct/basic-test/yaffscfg2k.c index de8953e..6f7d212 100644 --- a/direct/basic-test/yaffscfg2k.c +++ b/direct/basic-test/yaffscfg2k.c @@ -65,7 +65,7 @@ void yaffsfs_Unlock(void) { } -__u32 yaffsfs_CurrentTime(void) +u32 yaffsfs_CurrentTime(void) { return 0; } @@ -106,9 +106,9 @@ void yaffsfs_LocalInitialisation(void) #include "yaffs_flashif2.h" #include "yaffs_nandemul2k.h" -struct yaffs_dev_s ram1Dev; -struct yaffs_dev_s flashDev; -struct yaffs_dev_s m18_1Dev; +struct yaffs_dev ram1Dev; +struct yaffs_dev flashDev; +struct yaffs_dev m18_1Dev; int yaffs_start_up(void) { diff --git a/direct/basic-test/yaffsnewcfg.c b/direct/basic-test/yaffsnewcfg.c index a3548ef..60dcf02 100644 --- a/direct/basic-test/yaffsnewcfg.c +++ b/direct/basic-test/yaffsnewcfg.c @@ -59,7 +59,7 @@ void yaffsfs_Unlock(void) { } -__u32 yaffsfs_CurrentTime(void) +u32 yaffsfs_CurrentTime(void) { return 0; } diff --git a/direct/basic-test/ynorsim.c b/direct/basic-test/ynorsim.c index ab72d28..3965101 100644 --- a/direct/basic-test/ynorsim.c +++ b/direct/basic-test/ynorsim.c @@ -48,7 +48,7 @@ #define YNORSIM_DEV_SIZE_U32 (8*1024 * 1024/4) #endif -static __u32 word[YNORSIM_DEV_SIZE_U32]; +static u32 word[YNORSIM_DEV_SIZE_U32]; extern int random_seed; extern int simulate_power_failure; @@ -111,7 +111,7 @@ static void ynorsim_ready(void) ynorsim_restore_image(); } -void ynorsim_rd32(__u32 *addr,__u32 *buf, int nwords) +void ynorsim_rd32(u32 *addr,u32 *buf, int nwords) { while(nwords > 0){ *buf = *addr; @@ -121,10 +121,10 @@ void ynorsim_rd32(__u32 *addr,__u32 *buf, int nwords) } } -void ynorsim_wr_one_word32(__u32 *addr,__u32 val) +void ynorsim_wr_one_word32(u32 *addr,u32 val) { - __u32 tmp; - __u32 m; + u32 tmp; + u32 m; int i; tmp = *addr; @@ -148,7 +148,7 @@ void ynorsim_wr_one_word32(__u32 *addr,__u32 val) ynorsim_maybe_power_fail(); } -void ynorsim_wr32(__u32 *addr, __u32 *buf, int nwords) +void ynorsim_wr32(u32 *addr, u32 *buf, int nwords) { while(nwords >0){ ynorsim_wr_one_word32(addr,*buf); @@ -158,7 +158,7 @@ void ynorsim_wr32(__u32 *addr, __u32 *buf, int nwords) } } -void ynorsim_erase(__u32 *addr) +void ynorsim_erase(u32 *addr) { /* Todo... bit flipping */ memset(addr,0xFF,YNORSIM_BLOCK_SIZE_U32 * 4); @@ -175,7 +175,7 @@ void ynorsim_shutdown(void) initialised=0; } -__u32 *ynorsim_get_base(void) +u32 *ynorsim_get_base(void) { return word; } diff --git a/direct/basic-test/ynorsim.h b/direct/basic-test/ynorsim.h index e0e92b1..ca5bdf1 100644 --- a/direct/basic-test/ynorsim.h +++ b/direct/basic-test/ynorsim.h @@ -18,11 +18,11 @@ #include "yaffs_guts.h" -void ynorsim_rd32(__u32 *addr, __u32 *data, int nwords); -void ynorsim_wr32(__u32 *addr, __u32 *data, int nwords); -void ynorsim_erase(__u32 *addr); +void ynorsim_rd32(u32 *addr, u32 *data, int nwords); +void ynorsim_wr32(u32 *addr, u32 *data, int nwords); +void ynorsim_erase(u32 *addr); void ynorsim_shutdown(void); void ynorsim_initialise(void); -__u32 * ynorsim_get_base(void); +u32 * ynorsim_get_base(void); #endif diff --git a/direct/basic-test/yramsim.c b/direct/basic-test/yramsim.c index 74d5f73..9b50a39 100644 --- a/direct/basic-test/yramsim.c +++ b/direct/basic-test/yramsim.c @@ -41,7 +41,7 @@ typedef struct { SimData *simDevs[N_RAM_SIM_DEVS]; -static SimData *DevToSim(yaffs_dev_t *dev) +static SimData *DevToSim(struct yaffs_dev *dev) { ynandif_Geometry *geom = (ynandif_Geometry *)(dev->driver_context); SimData * sim = (SimData*)(geom->privateData); @@ -77,7 +77,7 @@ static int yramsim_erase_internal(SimData *sim, unsigned blockId,int force) -static int yramsim_initialise(yaffs_dev_t *dev) +static int yramsim_initialise(struct yaffs_dev *dev) { SimData *sim = DevToSim(dev); Block **blockList = sim->blockList; @@ -85,12 +85,12 @@ static int yramsim_initialise(yaffs_dev_t *dev) } -static int yramsim_deinitialise(yaffs_dev_t *dev) +static int yramsim_deinitialise(struct yaffs_dev *dev) { return 1; } -static int yramsim_rd_chunk (yaffs_dev_t *dev, unsigned pageId, +static int yramsim_rd_chunk (struct yaffs_dev *dev, unsigned pageId, unsigned char *data, unsigned dataLength, unsigned char *spare, unsigned spareLength, int *eccStatus) @@ -125,7 +125,7 @@ static int yramsim_rd_chunk (yaffs_dev_t *dev, unsigned pageId, return 1; } -static int yramsim_wr_chunk (yaffs_dev_t *dev,unsigned pageId, +static int yramsim_wr_chunk (struct yaffs_dev *dev,unsigned pageId, const unsigned char *data, unsigned dataLength, const unsigned char *spare, unsigned spareLength) { @@ -157,7 +157,7 @@ static int yramsim_wr_chunk (yaffs_dev_t *dev,unsigned pageId, } -static int yramsim_erase(yaffs_dev_t *dev,unsigned blockId) +static int yramsim_erase(struct yaffs_dev *dev,unsigned blockId) { SimData *sim = DevToSim(dev); @@ -165,7 +165,7 @@ static int yramsim_erase(yaffs_dev_t *dev,unsigned blockId) return yramsim_erase_internal(sim,blockId,0); } -static int yramsim_check_block_ok(yaffs_dev_t *dev,unsigned blockId) +static int yramsim_check_block_ok(struct yaffs_dev *dev,unsigned blockId) { SimData *sim = DevToSim(dev); Block **blockList = sim->blockList; @@ -176,7 +176,7 @@ static int yramsim_check_block_ok(yaffs_dev_t *dev,unsigned blockId) return blockList[blockId]->blockOk ? 1 : 0; } -static int yramsim_mark_block_bad(yaffs_dev_t *dev,unsigned blockId) +static int yramsim_mark_block_bad(struct yaffs_dev *dev,unsigned blockId) { SimData *sim = DevToSim(dev); Block **blockList = sim->blockList; @@ -190,14 +190,14 @@ static int yramsim_mark_block_bad(yaffs_dev_t *dev,unsigned blockId) } -static SimData *yramsim_alloc_sim_data(__u32 devId, __u32 nBlocks) +static SimData *yramsim_alloc_sim_data(u32 devId, u32 nBlocks) { int ok = 1; Block **blockList; SimData *sim; Block *b; - __u32 i; + u32 i; if(devId >= N_RAM_SIM_DEVS) return NULL; @@ -251,9 +251,9 @@ static SimData *yramsim_alloc_sim_data(__u32 devId, __u32 nBlocks) } -struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name, - __u32 devId, __u32 nBlocks, - __u32 start_block, __u32 end_block) +struct yaffs_dev *yramsim_CreateRamSim(const YCHAR *name, + u32 devId, u32 nBlocks, + u32 start_block, u32 end_block) { SimData *sim; ynandif_Geometry *g; diff --git a/direct/basic-test/yramsim.h b/direct/basic-test/yramsim.h index 4f20364..b27b69f 100644 --- a/direct/basic-test/yramsim.h +++ b/direct/basic-test/yramsim.h @@ -23,9 +23,9 @@ #define N_RAM_SIM_DEVS 2 -struct yaffs_dev_s *yramsim_CreateRamSim(const YCHAR *name, - __u32 devId, __u32 nBlocks, - __u32 start_block, __u32 end_block); +struct yaffs_dev *yramsim_CreateRamSim(const YCHAR *name, + u32 devId, u32 nBlocks, + u32 start_block, u32 end_block); #endif diff --git a/direct/python/Makefile b/direct/python/Makefile index f2eac15..7c7a063 100644 --- a/direct/python/Makefile +++ b/direct/python/Makefile @@ -30,7 +30,7 @@ CFLAGS += -O0 -fPIC COMMONTESTOBJS = yaffscfg2k.o yramsim.o yaffs_fileem2k.o\ - yaffs_nandif.o \ + yaffs_nandif.o yaffs_attribs.o \ yaffsfs.o yaffs_ecc.o yaffs_guts.o \ yaffs_packedtags1.o yaffs_ramdisk.o yaffs_ramem2k.o \ yaffs_tagscompat.o yaffs_packedtags2.o yaffs_tagsvalidity.o yaffs_nand.o \ @@ -47,12 +47,12 @@ YAFFSLIBOBJS = $(COMMONTESTOBJS) yaffs_python_helper.o yaffs_error_converter.o -YAFFSSYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yportenv.h yaffs_tagscompat.c yaffs_tagscompat.h \ +YAFFSSYMLINKS = yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yaffs_tagscompat.c yaffs_tagscompat.h \ yaffs_packedtags1.c yaffs_packedtags1.h yaffs_packedtags2.c yaffs_packedtags2.h \ - yaffs_nand.c yaffs_nand.h yaffs_getblockinfo.h yaffs_list.h \ + yaffs_nand.c yaffs_nand.h yaffs_getblockinfo.h \ yaffs_tagsvalidity.c yaffs_tagsvalidity.h yaffs_checkptrw.h yaffs_checkptrw.c \ - yaffs_nameval.c yaffs_nameval.h \ - yaffs_qsort.h yaffs_trace.h \ + yaffs_nameval.c yaffs_nameval.h yaffs_attribs.h \ + yaffs_trace.h \ yaffs_allocator.c yaffs_allocator.h \ yaffs_yaffs1.c yaffs_yaffs1.h \ yaffs_yaffs2.c yaffs_yaffs2.h \ @@ -61,8 +61,9 @@ YAFFSSYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yp YAFFSDIRECTSYMLINKS = yaffsfs.c yaffsfs.h yaffscfg.h yaffs_malloc.h ydirectenv.h \ - yaffs_flashif.c yaffs_flashif.h yaffs_flashif2.h\ - yaffs_nandif.c yaffs_nandif.h yaffs_qsort.c yaffs_nandemul2k.h + yaffs_flashif.c yaffs_flashif.h yaffs_flashif2.h yaffs_list.h \ + yaffs_nandif.c yaffs_nandif.h yaffs_qsort.c yaffs_nandemul2k.h \ + yportenv.h yaffs_attribs.c DIRECTEXTRASYMLINKS = yaffscfg2k.c yaffs_fileem2k.c yaffs_fileem2k.h\ yaffs_fileem.c yaffs_norif1.c yaffs_norif1.h \ diff --git a/direct/tests/Makefile b/direct/tests/Makefile index 5800b0a..016b934 100644 --- a/direct/tests/Makefile +++ b/direct/tests/Makefile @@ -34,7 +34,7 @@ COMMONTESTOBJS = yaffscfg2k.o yaffs_ecc.o yaffs_fileem.o yaffs_fileem2k.o yaffsf yaffs_packedtags1.o yaffs_ramdisk.o yaffs_ramem2k.o \ yaffs_tagscompat.o yaffs_packedtags2.o yaffs_tagsvalidity.o yaffs_nand.o \ yaffs_checkptrw.o yaffs_qsort.o\ - yaffs_nameval.o \ + yaffs_nameval.o yaffs_attribs.o \ yaffs_norif1.o ynorsim.o nor_stress.o yaffs_fsx.o \ yaffs_allocator.o \ yaffs_bitmap.o \ @@ -49,12 +49,12 @@ YAFFSTESTOBJS = $(COMMONTESTOBJS) yaffs_test.o ALLOBJS = $(sort $(YAFFSTESTOBJS)) -YAFFSSYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yportenv.h yaffs_tagscompat.c yaffs_tagscompat.h \ +YAFFSSYMLINKS = yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yaffs_tagscompat.c yaffs_tagscompat.h \ yaffs_packedtags1.c yaffs_packedtags1.h yaffs_packedtags2.c yaffs_packedtags2.h yaffs_nandemul2k.h \ - yaffs_nand.c yaffs_nand.h yaffs_getblockinfo.h yaffs_list.h \ + yaffs_nand.c yaffs_nand.h yaffs_getblockinfo.h \ yaffs_tagsvalidity.c yaffs_tagsvalidity.h yaffs_checkptrw.h yaffs_checkptrw.c \ yaffs_nameval.c yaffs_nameval.h \ - yaffs_qsort.h yaffs_trace.h \ + yaffs_trace.h yaffs_attribs.h \ yaffs_allocator.c yaffs_allocator.h \ yaffs_yaffs1.c yaffs_yaffs1.h \ yaffs_yaffs2.c yaffs_yaffs2.h \ @@ -64,8 +64,9 @@ YAFFSSYMLINKS = devextras.h yaffs_ecc.c yaffs_ecc.h yaffs_guts.c yaffs_guts.h yp YAFFSDIRECTSYMLINKS = yaffsfs.c yaffs_flashif.h yaffs_flashif2.h\ yaffsfs.h yaffs_malloc.h ydirectenv.h \ yaffs_flashif.c yaffscfg.h yaffs_qsort.c \ - yaffs_nandemul2k.h \ - yaffs_nandif.c yaffs_nandif.h + yaffs_nandemul2k.h yaffs_list.h \ + yaffs_attribs.c \ + yaffs_nandif.c yaffs_nandif.h yportenv.h DIRECTEXTRASYMLINKS = yaffscfg2k.c yaffs_fileem2k.c yaffs_fileem2k.h\ diff --git a/direct/yaffs_attribs.c b/direct/yaffs_attribs.c new file mode 100644 index 0000000..89cd7fc --- /dev/null +++ b/direct/yaffs_attribs.c @@ -0,0 +1,153 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "yaffs_attribs.h" + + +void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) +{ + obj->yst_uid = oh->yst_uid; + obj->yst_gid = oh->yst_gid; + obj->yst_atime = oh->yst_atime; + obj->yst_mtime = oh->yst_mtime; + obj->yst_ctime = oh->yst_ctime; + obj->yst_rdev = oh->yst_rdev; +} + + +void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj) +{ +#ifdef CONFIG_YAFFS_WINCE + oh->win_atime[0] = obj->win_atime[0]; + oh->win_ctime[0] = obj->win_ctime[0]; + oh->win_mtime[0] = obj->win_mtime[0]; + oh->win_atime[1] = obj->win_atime[1]; + oh->win_ctime[1] = obj->win_ctime[1]; + oh->win_mtime[1] = obj->win_mtime[1]; +#else + oh->yst_uid = obj->yst_uid; + oh->yst_gid = obj->yst_gid; + oh->yst_atime = obj->yst_atime; + oh->yst_mtime = obj->yst_mtime; + oh->yst_ctime = obj->yst_ctime; + oh->yst_rdev = obj->yst_rdev; +#endif + +} + +void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev) +{ + +#ifdef CONFIG_YAFFS_WINCE + yfsd_win_file_time_now(obj->win_atime); + obj->win_ctime[0] = obj->win_mtime[0] = obj->win_atime[0]; + obj->win_ctime[1] = obj->win_mtime[1] = obj->win_atime[1]; + +#else + yaffs_load_current_time(obj,1,1); + obj->yst_rdev = rdev; + obj->yst_uid = uid; + obj->yst_gid = gid; +#endif +} + +void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c) +{ +#ifdef CONFIG_YAFFS_WINCE + yfsd_win_file_time_now(the_obj->win_atime); + the_obj->win_ctime[0] = the_obj->win_mtime[0] = + the_obj->win_atime[0]; + the_obj->win_ctime[1] = the_obj->win_mtime[1] = + the_obj->win_atime[1]; + +#else + + obj->yst_mtime = Y_CURRENT_TIME; + if(do_a) + obj->yst_atime = obj->yst_atime; + if(do_c) + obj->yst_ctime = obj->yst_atime; +#endif +} + +loff_t yaffs_get_file_size(struct yaffs_obj *obj) +{ + YCHAR *alias = NULL; + obj = yaffs_get_equivalent_obj(obj); + + switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: + return obj->variant.file_variant.file_size; + case YAFFS_OBJECT_TYPE_SYMLINK: + alias = obj->variant.symlink_variant.alias; + if(!alias) + return 0; + return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH); + default: + return 0; + } +} + +int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = attr->ia_valid; + + if (valid & ATTR_MODE) + obj->yst_mode = attr->ia_mode; + if (valid & ATTR_UID) + obj->yst_uid = attr->ia_uid; + if (valid & ATTR_GID) + obj->yst_gid = attr->ia_gid; + + if (valid & ATTR_ATIME) + obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime); + if (valid & ATTR_CTIME) + obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime); + if (valid & ATTR_MTIME) + obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); + + if (valid & ATTR_SIZE) + yaffs_resize_file(obj, attr->ia_size); + + yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); + + return YAFFS_OK; + +} + +int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = 0; + + attr->ia_mode = obj->yst_mode; + valid |= ATTR_MODE; + attr->ia_uid = obj->yst_uid; + valid |= ATTR_UID; + attr->ia_gid = obj->yst_gid; + valid |= ATTR_GID; + + Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime; + valid |= ATTR_ATIME; + Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime; + valid |= ATTR_CTIME; + Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; + valid |= ATTR_MTIME; + + attr->ia_size = yaffs_get_file_size(obj); + valid |= ATTR_SIZE; + + attr->ia_valid = valid; + + return YAFFS_OK; +} + diff --git a/direct/yaffs_flashif.c b/direct/yaffs_flashif.c index 79732a1..8595804 100644 --- a/direct/yaffs_flashif.c +++ b/direct/yaffs_flashif.c @@ -19,7 +19,6 @@ const char *yaffs_flashif_c_version = "$Id: yaffs_flashif.c,v 1.3 2007-02-14 01: #include "yaffs_flashif.h" #include "yaffs_guts.h" -#include "devextras.h" #define SIZE_IN_MB 16 @@ -31,7 +30,7 @@ const char *yaffs_flashif_c_version = "$Id: yaffs_flashif.c,v 1.3 2007-02-14 01: typedef struct { - __u8 data[528]; // Data + spare + u8 data[528]; // Data + spare } yflash_Page; typedef struct @@ -50,7 +49,7 @@ typedef struct static yflash_Device ramdisk; -static int CheckInit(yaffs_dev_t *dev) +static int CheckInit(struct yaffs_dev *dev) { static int initialised = 0; @@ -108,7 +107,7 @@ static int CheckInit(yaffs_dev_t *dev) return 1; } -int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, yaffs_ext_tags *tags) +int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, struct yaffs_ext_tags *tags) { int blk; int pg; @@ -138,7 +137,7 @@ int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 * } -int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_tags_t *tags) +int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_tags *tags) { int blk; int pg; @@ -167,7 +166,7 @@ int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data } -int yflash_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk) +int yflash_CheckChunkErased(struct yaffs_dev *dev,int nand_chunk) { int blk; int pg; @@ -192,7 +191,7 @@ int yflash_CheckChunkErased(yaffs_dev_t *dev,int nand_chunk) } -int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) +int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber) { CheckInit(dev); @@ -210,19 +209,19 @@ int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber) } -int yflash_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) +int yflash_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no) { return YAFFS_OK; } -int yflash_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, int *seq_number) +int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, int *seq_number) { *state = YAFFS_BLOCK_STATE_EMPTY; *seq_number = 0; } -int yflash_InitialiseNAND(yaffs_dev_t *dev) +int yflash_InitialiseNAND(struct yaffs_dev *dev) { return YAFFS_OK; } diff --git a/direct/yaffs_flashif.h b/direct/yaffs_flashif.h index bc3ed70..b169170 100644 --- a/direct/yaffs_flashif.h +++ b/direct/yaffs_flashif.h @@ -18,13 +18,13 @@ #include "yaffs_guts.h" -int yflash_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber); -int yflash_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare); -int yflash_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags); -int yflash_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare); -int yflash_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags); -int yflash_InitialiseNAND(yaffs_dev_t *dev); -int yflash_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); -int yflash_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number); +int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber); +int yflash_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare); +int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags); +int yflash_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare); +int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags); +int yflash_InitialiseNAND(struct yaffs_dev *dev); +int yflash_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no); +int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number); #endif diff --git a/direct/yaffs_flashif2.h b/direct/yaffs_flashif2.h index de82085..75a66de 100644 --- a/direct/yaffs_flashif2.h +++ b/direct/yaffs_flashif2.h @@ -18,14 +18,13 @@ #include "yaffs_guts.h" -int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber); -int yflash2_WriteChunkToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_spare *spare); -int yflash2_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags); -int yflash2_ReadChunkFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_spare *spare); -int yflash2_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags); -int yflash2_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber); -int yflash2_InitialiseNAND(yaffs_dev_t *dev); -int yflash2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); -int yflash2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number); +int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber); +int yflash2_WriteChunkToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_spare *spare); +int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags); +int yflash2_ReadChunkFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_spare *spare); +int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags); +int yflash2_InitialiseNAND(struct yaffs_dev *dev); +int yflash2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no); +int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number); #endif diff --git a/yaffs_list.h b/direct/yaffs_list.h similarity index 64% rename from yaffs_list.h rename to direct/yaffs_list.h index 145a1c5..624cd5f 100644 --- a/yaffs_list.h +++ b/direct/yaffs_list.h @@ -31,20 +31,20 @@ * way the Linux kernel doubly linked list implementation works. */ -struct ylist_head { - struct ylist_head *next; /* next in chain */ - struct ylist_head *prev; /* previous in chain */ +struct list_head { + struct list_head *next; /* next in chain */ + struct list_head *prev; /* previous in chain */ }; /* Initialise a static list */ -#define YLIST_HEAD(name) \ -struct ylist_head name = { &(name), &(name)} +#define LIST_HEAD(name) \ +struct list_head name = { &(name), &(name)} /* Initialise a list head to an empty list */ -#define YINIT_LIST_HEAD(p) \ +#define INIT_LIST_HEAD(p) \ do { \ (p)->next = (p);\ (p)->prev = (p); \ @@ -52,10 +52,10 @@ do { \ /* Add an element to a list */ -static Y_INLINE void ylist_add(struct ylist_head *new_entry, - struct ylist_head *list) +static Y_INLINE void list_add(struct list_head *new_entry, + struct list_head *list) { - struct ylist_head *list_next = list->next; + struct list_head *list_next = list->next; list->next = new_entry; new_entry->prev = list; @@ -64,10 +64,10 @@ static Y_INLINE void ylist_add(struct ylist_head *new_entry, } -static Y_INLINE void ylist_add_tail(struct ylist_head *new_entry, - struct ylist_head *list) +static Y_INLINE void list_add_tail(struct list_head *new_entry, + struct list_head *list) { - struct ylist_head *list_prev = list->prev; + struct list_head *list_prev = list->prev; list->prev = new_entry; new_entry->next = list; @@ -79,47 +79,47 @@ static Y_INLINE void ylist_add_tail(struct ylist_head *new_entry, /* Take an element out of its current list, with or without * reinitialising the links.of the entry*/ -static Y_INLINE void ylist_del(struct ylist_head *entry) +static Y_INLINE void list_del(struct list_head *entry) { - struct ylist_head *list_next = entry->next; - struct ylist_head *list_prev = entry->prev; + struct list_head *list_next = entry->next; + struct list_head *list_prev = entry->prev; list_next->prev = list_prev; list_prev->next = list_next; } -static Y_INLINE void ylist_del_init(struct ylist_head *entry) +static Y_INLINE void list_del_init(struct list_head *entry) { - ylist_del(entry); + list_del(entry); entry->next = entry->prev = entry; } /* Test if the list is empty */ -static Y_INLINE int ylist_empty(struct ylist_head *entry) +static Y_INLINE int list_empty(struct list_head *entry) { return (entry->next == entry); } -/* ylist_entry takes a pointer to a list entry and offsets it to that +/* list_entry takes a pointer to a list entry and offsets it to that * we can find a pointer to the object it is embedded in. */ -#define ylist_entry(entry, type, member) \ +#define list_entry(entry, type, member) \ ((type *)((char *)(entry)-(unsigned long)(&((type *)NULL)->member))) -/* ylist_for_each and list_for_each_safe iterate over lists. - * ylist_for_each_safe uses temporary storage to make the list delete safe +/* list_for_each and list_for_each_safe iterate over lists. + * list_for_each_safe uses temporary storage to make the list delete safe */ -#define ylist_for_each(itervar, list) \ +#define list_for_each(itervar, list) \ for (itervar = (list)->next; itervar != (list); itervar = itervar->next) -#define ylist_for_each_safe(itervar, save_var, list) \ +#define list_for_each_safe(itervar, save_var, list) \ for (itervar = (list)->next, save_var = (list)->next->next; \ itervar != (list); itervar = save_var, save_var = save_var->next) diff --git a/direct/yaffs_nandemul2k.h b/direct/yaffs_nandemul2k.h index 30b7cbd..739e118 100644 --- a/direct/yaffs_nandemul2k.h +++ b/direct/yaffs_nandemul2k.h @@ -20,18 +20,18 @@ #include "yaffs_guts.h" -int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev_s *dev, - int nand_chunk, const __u8 *data, - const yaffs_ext_tags *tags); -int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev_s *dev, - int nand_chunk, __u8 *data, - yaffs_ext_tags *tags); -int nandemul2k_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no); -int nandemul2k_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, - yaffs_block_state_t *state, __u32 *seq_number); -int nandemul2k_EraseBlockInNAND(struct yaffs_dev_s *dev, +int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, + int nand_chunk, const u8 *data, + const struct yaffs_ext_tags *tags); +int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, + int nand_chunk, u8 *data, + struct yaffs_ext_tags *tags); +int nandemul2k_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no); +int nandemul2k_QueryNANDBlock(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 *seq_number); +int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, int flash_block); -int nandemul2k_InitialiseNAND(struct yaffs_dev_s *dev); +int nandemul2k_InitialiseNAND(struct yaffs_dev *dev); int nandemul2k_GetBytesPerChunk(void); int nandemul2k_GetChunksPerBlock(void); int nandemul2k_GetNumberOfBlocks(void); diff --git a/direct/yaffs_nandif.c b/direct/yaffs_nandif.c index 135e894..9a22f7f 100644 --- a/direct/yaffs_nandif.c +++ b/direct/yaffs_nandif.c @@ -13,7 +13,6 @@ #include "yportenv.h" #include "yaffs_guts.h" -#include "devextras.h" #include "yaffs_nandif.h" @@ -29,13 +28,13 @@ * We assume that the data buffer is of size totalBytersPerChunk so that we can also * use it to load the tags. */ -int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, - const __u8 * data, - const yaffs_ext_tags * tags) +int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags * tags) { int retval = 0; - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; void *spare; unsigned spareSize = 0; ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); @@ -52,8 +51,8 @@ int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, */ if(dev->param.inband_tags){ - yaffs_packed_tags2_tags_only *pt2tp; - pt2tp = (yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk); + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = (struct yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk); yaffs_pack_tags2_tags_only(pt2tp,tags); spare = NULL; spareSize = 0; @@ -61,7 +60,7 @@ int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, else{ yaffs_pack_tags2(&pt, tags,!dev->param.no_tags_ecc); spare = &pt; - spareSize = sizeof(yaffs_packed_tags2); + spareSize = sizeof(struct yaffs_packed_tags2); } retval = geometry->writeChunk(dev,nand_chunk, @@ -70,10 +69,10 @@ int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, return retval; } -int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, - __u8 * data, yaffs_ext_tags * tags) +int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev * dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags * tags) { - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; int localData = 0; void *spare = NULL; unsigned spareSize; @@ -100,7 +99,7 @@ int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, } else { spare = &pt; - spareSize = sizeof(yaffs_packed_tags2); + spareSize = sizeof(struct yaffs_packed_tags2); } retval = geometry->readChunk(dev,nand_chunk, @@ -111,8 +110,8 @@ int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, if(dev->param.inband_tags){ if(tags){ - yaffs_packed_tags2_tags_only * pt2tp; - pt2tp = (yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; + struct yaffs_packed_tags2_tags_only * pt2tp; + pt2tp = (struct yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; yaffs_unpack_tags2_tags_only(tags,pt2tp); } } @@ -139,14 +138,14 @@ int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, return retval; } -int ynandif_MarkNANDBlockBad(struct yaffs_dev_s *dev, int blockId) +int ynandif_MarkNANDBlockBad(struct yaffs_dev *dev, int blockId) { ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); return geometry->markBlockBad(dev,blockId); } -int ynandif_EraseBlockInNAND(struct yaffs_dev_s *dev, int blockId) +int ynandif_EraseBlockInNAND(struct yaffs_dev *dev, int blockId) { ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); @@ -155,17 +154,17 @@ int ynandif_EraseBlockInNAND(struct yaffs_dev_s *dev, int blockId) } -static int ynandif_IsBlockOk(struct yaffs_dev_s *dev, int blockId) +static int ynandif_IsBlockOk(struct yaffs_dev *dev, int blockId) { ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); return geometry->checkBlockOk(dev,blockId); } -int ynandif_QueryNANDBlock(struct yaffs_dev_s *dev, int blockId, yaffs_block_state_t *state, __u32 *seq_number) +int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, enum yaffs_block_state *state, u32 *seq_number) { unsigned chunkNo; - yaffs_ext_tags tags; + struct yaffs_ext_tags tags; *seq_number = 0; @@ -193,7 +192,7 @@ int ynandif_QueryNANDBlock(struct yaffs_dev_s *dev, int blockId, yaffs_block_sta } -int ynandif_InitialiseNAND(yaffs_dev_t *dev) +int ynandif_InitialiseNAND(struct yaffs_dev *dev) { ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); @@ -202,7 +201,7 @@ int ynandif_InitialiseNAND(yaffs_dev_t *dev) return YAFFS_OK; } -int ynandif_Deinitialise_flash_fn(yaffs_dev_t *dev) +int ynandif_Deinitialise_flash_fn(struct yaffs_dev *dev) { ynandif_Geometry *geometry = (ynandif_Geometry *)(dev->driver_context); @@ -212,15 +211,15 @@ int ynandif_Deinitialise_flash_fn(yaffs_dev_t *dev) } -struct yaffs_dev_s * +struct yaffs_dev * yaffs_add_dev_from_geometry(const YCHAR *name, const ynandif_Geometry *geometry) { YCHAR *clonedName = YMALLOC(sizeof(YCHAR) * (yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH)+1)); - struct yaffs_dev_s *dev = YMALLOC(sizeof(struct yaffs_dev_s)); + struct yaffs_dev *dev = YMALLOC(sizeof(struct yaffs_dev)); if(dev && clonedName){ - memset(dev,0,sizeof(struct yaffs_dev_s)); + memset(dev,0,sizeof(struct yaffs_dev)); yaffs_strcpy(clonedName,name); dev->param.name = clonedName; diff --git a/direct/yaffs_nandif.h b/direct/yaffs_nandif.h index b8e3ba0..a130f3c 100644 --- a/direct/yaffs_nandif.h +++ b/direct/yaffs_nandif.h @@ -30,43 +30,43 @@ typedef struct { unsigned inband_tags; unsigned useYaffs2; - int (*initialise)(yaffs_dev_t *dev); - int (*deinitialise)(yaffs_dev_t *dev); + int (*initialise)(struct yaffs_dev *dev); + int (*deinitialise)(struct yaffs_dev *dev); - int (*readChunk) (yaffs_dev_t *dev, + int (*readChunk) (struct yaffs_dev *dev, unsigned pageId, unsigned char *data, unsigned dataLength, unsigned char *spare, unsigned spareLength, int *eccStatus); // ECC status is set to 0 for OK, 1 for fixed, -1 for unfixed. - int (*writeChunk)(yaffs_dev_t *dev, + int (*writeChunk)(struct yaffs_dev *dev, unsigned pageId, const unsigned char *data, unsigned dataLength, const unsigned char *spare, unsigned spareLength); - int (*eraseBlock)(yaffs_dev_t *dev, unsigned blockId); + int (*eraseBlock)(struct yaffs_dev *dev, unsigned blockId); - int (*checkBlockOk)(yaffs_dev_t *dev, unsigned blockId); - int (*markBlockBad)(yaffs_dev_t *dev, unsigned blockId); + int (*checkBlockOk)(struct yaffs_dev *dev, unsigned blockId); + int (*markBlockBad)(struct yaffs_dev *dev, unsigned blockId); void *privateData; } ynandif_Geometry; -struct yaffs_dev_s * +struct yaffs_dev * yaffs_add_dev_from_geometry(const YCHAR *name, const ynandif_Geometry *geometry); #if 0 -int ynandif_WriteChunkWithTagsToNAND(yaffs_dev_t *dev,int nand_chunk,const __u8 *data, const yaffs_ext_tags *tags); -int ynandif_ReadChunkWithTagsFromNAND(yaffs_dev_t *dev,int nand_chunk, __u8 *data, yaffs_ext_tags *tags); -int ynandif_EraseBlockInNAND(yaffs_dev_t *dev, int blockNumber); -int ynandif_InitialiseNAND(yaffs_dev_t *dev); -int ynandif_MarkNANDBlockBad(yaffs_dev_t *dev,int blockNumber); -int ynandif_QueryNANDBlock(yaffs_dev_t *dev, int block_no, yaffs_block_state_t *state, __u32 *seq_number); -int ynandif_GetGeometry(yaffs_dev_t *dev, ynandif_Geometry *geometry); +int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev *dev,int nand_chunk,const u8 *data, const struct yaffs_ext_tags *tags); +int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev,int nand_chunk, u8 *data, struct yaffs_ext_tags *tags); +int ynandif_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber); +int ynandif_InitialiseNAND(struct yaffs_dev *dev); +int ynandif_MarkNANDBlockBad(struct yaffs_dev *dev,int blockNumber); +int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int block_no, enum yaffs_block_state *state, u32 *seq_number); +int ynandif_GetGeometry(struct yaffs_dev *dev, ynandif_Geometry *geometry); #endif diff --git a/direct/yaffscfg.h b/direct/yaffscfg.h index c4cd48b..42fd78c 100644 --- a/direct/yaffscfg.h +++ b/direct/yaffscfg.h @@ -23,22 +23,21 @@ #define __YAFFSCFG_H__ -#include "yportenv.h" -#include "devextras.h" +#include "yportenv.h" #define YAFFSFS_N_HANDLES 100 typedef struct yaffsfs_DeviceConfigurationStruct { const YCHAR *prefix; - struct yaffs_dev_s *dev; + struct yaffs_dev *dev; } yaffsfs_DeviceConfiguration; void yaffsfs_Lock(void); void yaffsfs_Unlock(void); -__u32 yaffsfs_CurrentTime(void); +u32 yaffsfs_CurrentTime(void); void yaffsfs_SetError(int err); diff --git a/direct/yaffsfs.c b/direct/yaffsfs.c index 64a9491..b187142 100644 --- a/direct/yaffsfs.c +++ b/direct/yaffsfs.c @@ -31,8 +31,8 @@ #define YAFFSFS_RW_SIZE (1<iObj; @@ -302,7 +302,7 @@ int yaffsfs_IsPathDivider(YCHAR ch) -YLIST_HEAD(yaffsfs_deviceList); +LIST_HEAD(yaffsfs_deviceList); /* * yaffsfs_FindDevice @@ -311,13 +311,13 @@ YLIST_HEAD(yaffsfs_deviceList); * Curveballs: Should match paths that end in '/' too * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match */ -static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) +static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) { - struct ylist_head *cfg; + struct list_head *cfg; const YCHAR *leftOver; const YCHAR *p; - yaffs_dev_t *retval = NULL; - yaffs_dev_t *dev = NULL; + struct yaffs_dev *retval = NULL; + struct yaffs_dev *dev = NULL; int thisMatchLength; int longestMatch = -1; int matching; @@ -327,8 +327,8 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) * 1) Actually matches a prefix (ie /a amd /abc will not match * 2) Matches the longest. */ - ylist_for_each(cfg, &yaffsfs_deviceList){ - dev = ylist_entry(cfg, yaffs_dev_t, dev_list); + list_for_each(cfg, &yaffsfs_deviceList){ + dev = list_entry(cfg, struct yaffs_dev, dev_list); leftOver = path; p = dev->param.name; thisMatchLength = 0; @@ -383,12 +383,12 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) } #if 0 -static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) +static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) { yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList; const YCHAR *leftOver; const YCHAR *p; - yaffs_dev_t *retval = NULL; + struct yaffs_dev *retval = NULL; int thisMatchLength; int longestMatch = -1; @@ -425,10 +425,10 @@ static yaffs_dev_t *yaffsfs_FindDevice(const YCHAR *path, YCHAR **restOfPath) } #endif -static yaffs_obj_t *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath) +static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath) { - yaffs_dev_t *dev; + struct yaffs_dev *dev; dev= yaffsfs_FindDevice(path,restOfPath); if(dev && dev->is_mounted){ @@ -437,7 +437,7 @@ static yaffs_obj_t *yaffsfs_FindRoot(const YCHAR *path, YCHAR **restOfPath) return NULL; } -static yaffs_obj_t *yaffsfs_FollowLink(yaffs_obj_t *obj,int symDepth) +static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj,int symDepth) { if(obj) @@ -463,10 +463,10 @@ static yaffs_obj_t *yaffsfs_FollowLink(yaffs_obj_t *obj,int symDepth) * * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx" */ -static yaffs_obj_t *yaffsfs_DoFindDirectory(yaffs_obj_t *startDir, +static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir, const YCHAR *path, YCHAR **name, int symDepth) { - yaffs_obj_t *dir; + struct yaffs_obj *dir; YCHAR *restOfPath; YCHAR str[YAFFS_MAX_NAME_LENGTH+1]; int i; @@ -526,7 +526,7 @@ static yaffs_obj_t *yaffsfs_DoFindDirectory(yaffs_obj_t *startDir, return NULL; } -static yaffs_obj_t *yaffsfs_FindDirectory(yaffs_obj_t *relativeDirectory, +static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relativeDirectory, const YCHAR *path,YCHAR **name,int symDepth) { return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth); @@ -535,10 +535,10 @@ static yaffs_obj_t *yaffsfs_FindDirectory(yaffs_obj_t *relativeDirectory, /* * yaffsfs_FindObject turns a path for an existing object into the object */ -static yaffs_obj_t *yaffsfs_FindObject(yaffs_obj_t *relativeDirectory, const YCHAR *path,int symDepth, int getEquiv) +static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, const YCHAR *path,int symDepth, int getEquiv) { - yaffs_obj_t *dir; - yaffs_obj_t *obj; + struct yaffs_obj *dir; + struct yaffs_obj *obj; YCHAR *name; dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth); @@ -587,8 +587,8 @@ int yaffs_dup(int fd) int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) { - yaffs_obj_t *obj = NULL; - yaffs_obj_t *dir = NULL; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; YCHAR *name; int handle = -1; yaffsfs_Handle *yh = NULL; @@ -596,14 +596,14 @@ int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) int symDepth = 0; int errorReported = 0; int rwflags = oflag & ( O_RDWR | O_RDONLY | O_WRONLY); - __u8 shareRead = (sharing & YAFFS_SHARE_READ) ? 1 : 0; - __u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0; - __u8 sharedReadAllowed; - __u8 sharedWriteAllowed; - __u8 alreadyReading; - __u8 alreadyWriting; - __u8 readRequested; - __u8 writeRequested; + u8 shareRead = (sharing & YAFFS_SHARE_READ) ? 1 : 0; + u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0; + u8 sharedReadAllowed; + u8 sharedWriteAllowed; + u8 alreadyReading; + u8 alreadyWriting; + u8 readRequested; + u8 writeRequested; /* O_EXCL only has meaning if O_CREAT is specified */ if(!(oflag & O_CREAT)) @@ -829,14 +829,14 @@ int yaffs_close(int fd) int yaffsfs_do_read(int fd, void *vbuf, unsigned int nbyte, int isPread, int offset) { yaffsfs_Handle *h = NULL; - yaffs_obj_t *obj = NULL; + struct yaffs_obj *obj = NULL; int pos = 0; int startPos = 0; int nRead = 0; int nToRead = 0; int totalRead = 0; unsigned int maxRead; - __u8 *buf = (__u8 *)vbuf; + u8 *buf = (u8 *)vbuf; yaffsfs_Lock(); h = yaffsfs_GetHandlePointer(fd); @@ -925,14 +925,14 @@ int yaffs_pread(int fd, void *buf, unsigned int nbyte, unsigned int offset) int yaffsfs_do_write(int fd, const void *vbuf, unsigned int nbyte, int isPwrite, int offset) { yaffsfs_Handle *h = NULL; - yaffs_obj_t *obj = NULL; + struct yaffs_obj *obj = NULL; int pos = 0; int startPos = 0; int nWritten = 0; int totalWritten = 0; int write_trhrough = 0; int nToWrite = 0; - const __u8 *buf = (const __u8 *)vbuf; + const u8 *buf = (const u8 *)vbuf; yaffsfs_Lock(); h = yaffsfs_GetHandlePointer(fd); @@ -1012,7 +1012,7 @@ int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, unsigned int offse int yaffs_truncate(const YCHAR *path,off_t new_size) { - yaffs_obj_t *obj = NULL; + struct yaffs_obj *obj = NULL; int result = YAFFS_FAIL; yaffsfs_Lock(); @@ -1037,7 +1037,7 @@ int yaffs_truncate(const YCHAR *path,off_t new_size) int yaffs_ftruncate(int fd, off_t new_size) { yaffsfs_Handle *h = NULL; - yaffs_obj_t *obj = NULL; + struct yaffs_obj *obj = NULL; int result = 0; yaffsfs_Lock(); @@ -1062,7 +1062,7 @@ int yaffs_ftruncate(int fd, off_t new_size) off_t yaffs_lseek(int fd, off_t offset, int whence) { yaffsfs_Handle *h = NULL; - yaffs_obj_t *obj = NULL; + struct yaffs_obj *obj = NULL; int pos = -1; int fSize = -1; @@ -1100,8 +1100,8 @@ off_t yaffs_lseek(int fd, off_t offset, int whence) int yaffsfs_DoUnlink(const YCHAR *path,int isDirectory) { - yaffs_obj_t *dir = NULL; - yaffs_obj_t *obj = NULL; + struct yaffs_obj *dir = NULL; + struct yaffs_obj *obj = NULL; YCHAR *name; int result = YAFFS_FAIL; @@ -1146,9 +1146,9 @@ int yaffs_unlink(const YCHAR *path) int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) { - yaffs_obj_t *olddir = NULL; - yaffs_obj_t *newdir = NULL; - yaffs_obj_t *obj = NULL; + struct yaffs_obj *olddir = NULL; + struct yaffs_obj *newdir = NULL; + struct yaffs_obj *obj = NULL; YCHAR *oldname; YCHAR *newname; int result= YAFFS_FAIL; @@ -1179,7 +1179,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) * Do this by tracing from the new directory back to the root, checking for obj */ - yaffs_obj_t *xx = newdir; + struct yaffs_obj *xx = newdir; while( rename_allowed && xx){ if(xx == obj) @@ -1199,7 +1199,7 @@ int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) } -static int yaffsfs_DoStat(yaffs_obj_t *obj,struct yaffs_stat *buf) +static int yaffsfs_DoStat(struct yaffs_obj *obj,struct yaffs_stat *buf) { int retVal = -1; @@ -1243,7 +1243,7 @@ static int yaffsfs_DoStat(yaffs_obj_t *obj,struct yaffs_stat *buf) static int yaffsfs_DoStatOrLStat(const YCHAR *path, struct yaffs_stat *buf,int doLStat) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1278,7 +1278,7 @@ int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf) int yaffs_fstat(int fd, struct yaffs_stat *buf) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1302,7 +1302,7 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf) static int yaffs_do_setxattr(const YCHAR *path, const char *name, const void *data, int size, int flags, int follow) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1343,7 +1343,7 @@ int yaffs_lsetxattr(const YCHAR *path, const char *name, const void *data, int s int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int flags) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1367,7 +1367,7 @@ int yaffs_fsetxattr(int fd, const char *name, const void *data, int size, int fl static int yaffs_do_getxattr(const YCHAR *path, const char *name, void *data, int size, int follow) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1407,7 +1407,7 @@ int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size) int yaffs_fgetxattr(int fd, const char *name, void *data, int size) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1431,7 +1431,7 @@ int yaffs_fgetxattr(int fd, const char *name, void *data, int size) static int yaffs_do_listxattr(const YCHAR *path, char *data, int size, int follow) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1470,7 +1470,7 @@ int yaffs_llistxattr(const YCHAR *path, char *data, int size) int yaffs_flistxattr(int fd, char *data, int size) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1494,7 +1494,7 @@ int yaffs_flistxattr(int fd, char *data, int size) static int yaffs_do_removexattr(const YCHAR *path, const char *name, int follow) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1533,7 +1533,7 @@ int yaffs_lremovexattr(const YCHAR *path, const char *name) int yaffs_fremovexattr(int fd, const char *name) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1559,7 +1559,7 @@ int yaffs_fremovexattr(int fd, const char *name) #ifdef CONFIG_YAFFS_WINCE int yaffs_get_wince_times(int fd, unsigned *wctime, unsigned *watime, unsigned *wmtime) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1598,7 +1598,7 @@ int yaffs_set_wince_times(int fd, const unsigned *watime, const unsigned *wmtime) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int result; int retVal = -1; @@ -1635,7 +1635,7 @@ int yaffs_set_wince_times(int fd, #endif -static int yaffsfs_DoChMod(yaffs_obj_t *obj,mode_t mode) +static int yaffsfs_DoChMod(struct yaffs_obj *obj,mode_t mode) { int result = -1; @@ -1654,7 +1654,7 @@ static int yaffsfs_DoChMod(yaffs_obj_t *obj,mode_t mode) int yaffs_access(const YCHAR *path, int amode) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retval = 0; @@ -1691,7 +1691,7 @@ int yaffs_access(const YCHAR *path, int amode) int yaffs_chmod(const YCHAR *path, mode_t mode) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1715,7 +1715,7 @@ int yaffs_chmod(const YCHAR *path, mode_t mode) int yaffs_fchmod(int fd, mode_t mode) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int retVal = -1; @@ -1737,8 +1737,8 @@ int yaffs_fchmod(int fd, mode_t mode) int yaffs_mkdir(const YCHAR *path, mode_t mode) { - yaffs_obj_t *parent = NULL; - yaffs_obj_t *dir = NULL; + struct yaffs_obj *parent = NULL; + struct yaffs_obj *dir = NULL; YCHAR *name; YCHAR *use_path = NULL; int path_length = 0; @@ -1807,7 +1807,7 @@ int yaffs_mkdir(const YCHAR *path, mode_t mode) void * yaffs_getdev(const YCHAR *path) { - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; dev = yaffsfs_FindDevice(path,&dummy); return (void *)dev; @@ -1817,7 +1817,7 @@ int yaffs_mount2(const YCHAR *path,int read_only) { int retVal=-1; int result=YAFFS_FAIL; - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; T(YAFFS_TRACE_ALWAYS,(TSTR("yaffs: Mounting %s" TENDSTR),path)); @@ -1857,7 +1857,7 @@ int yaffs_mount(const YCHAR *path) int yaffs_sync(const YCHAR *path) { int retVal=-1; - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); @@ -1885,7 +1885,7 @@ int yaffs_sync(const YCHAR *path) int yaffs_remount(const YCHAR *path, int force, int read_only) { int retVal=-1; - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); @@ -1925,7 +1925,7 @@ int yaffs_remount(const YCHAR *path, int force, int read_only) int yaffs_unmount2(const YCHAR *path, int force) { int retVal=-1; - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); @@ -1973,7 +1973,7 @@ int yaffs_unmount(const YCHAR *path) loff_t yaffs_freespace(const YCHAR *path) { loff_t retVal=-1; - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); @@ -1992,7 +1992,7 @@ loff_t yaffs_freespace(const YCHAR *path) loff_t yaffs_totalspace(const YCHAR *path) { loff_t retVal=-1; - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); @@ -2012,7 +2012,7 @@ loff_t yaffs_totalspace(const YCHAR *path) int yaffs_inodecount(const YCHAR *path) { loff_t retVal= -1; - yaffs_dev_t *dev=NULL; + struct yaffs_dev *dev=NULL; YCHAR *dummy; yaffsfs_Lock(); @@ -2031,20 +2031,20 @@ int yaffs_inodecount(const YCHAR *path) } -void yaffs_add_device(yaffs_dev_t *dev) +void yaffs_add_device(struct yaffs_dev *dev) { dev->is_mounted = 0; dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback; if(!dev->dev_list.next) - YINIT_LIST_HEAD(&dev->dev_list); + INIT_LIST_HEAD(&dev->dev_list); - ylist_add(&dev->dev_list,&yaffsfs_deviceList); + list_add(&dev->dev_list,&yaffsfs_deviceList); } -void yaffs_remove_device(yaffs_dev_t *dev) +void yaffs_remove_device(struct yaffs_dev *dev) { - ylist_del_init(&dev->dev_list); + list_del_init(&dev->dev_list); } @@ -2061,18 +2061,18 @@ void yaffs_remove_device(yaffs_dev_t *dev) typedef struct { - __u32 magic; + u32 magic; yaffs_dirent de; /* directory entry being used by this dsc */ YCHAR name[NAME_MAX+1]; /* name of directory being searched */ - yaffs_obj_t *dirObj; /* ptr to directory being searched */ - yaffs_obj_t *nextReturn; /* obj to be returned by next readddir */ + struct yaffs_obj *dirObj; /* ptr to directory being searched */ + struct yaffs_obj *nextReturn; /* obj to be returned by next readddir */ int offset; - struct ylist_head others; + struct list_head others; } yaffsfs_DirectorySearchContext; -static struct ylist_head search_contexts; +static struct list_head search_contexts; static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc) @@ -2083,11 +2083,11 @@ static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc) dsc->offset = 0; - if( ylist_empty(&dsc->dirObj->variant.dir_variant.children)) + if( list_empty(&dsc->dirObj->variant.dir_variant.children)) dsc->nextReturn = NULL; else - dsc->nextReturn = ylist_entry(dsc->dirObj->variant.dir_variant.children.next, - yaffs_obj_t,siblings); + dsc->nextReturn = list_entry(dsc->dirObj->variant.dir_variant.children.next, + struct yaffs_obj,siblings); } else { /* Hey someone isn't playing nice! */ } @@ -2100,25 +2100,25 @@ static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc) dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY){ if( dsc->nextReturn == NULL || - ylist_empty(&dsc->dirObj->variant.dir_variant.children)) + list_empty(&dsc->dirObj->variant.dir_variant.children)) dsc->nextReturn = NULL; else { - struct ylist_head *next = dsc->nextReturn->siblings.next; + struct list_head *next = dsc->nextReturn->siblings.next; if( next == &dsc->dirObj->variant.dir_variant.children) dsc->nextReturn = NULL; /* end of list */ else - dsc->nextReturn = ylist_entry(next,yaffs_obj_t,siblings); + dsc->nextReturn = list_entry(next,struct yaffs_obj,siblings); } } else { /* Hey someone isn't playing nice! */ } } -static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj) +static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj) { - struct ylist_head *i; + struct list_head *i; yaffsfs_DirectorySearchContext *dsc; /* if search contexts not initilised then skip */ @@ -2129,9 +2129,9 @@ static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj) * If any are the one being removed, then advance the dsc to * the next one to prevent a hanging ptr. */ - ylist_for_each(i, &search_contexts) { + list_for_each(i, &search_contexts) { if (i) { - dsc = ylist_entry(i, yaffsfs_DirectorySearchContext,others); + dsc = list_entry(i, yaffsfs_DirectorySearchContext,others); if(dsc->nextReturn == obj) yaffsfs_DirAdvance(dsc); } @@ -2142,7 +2142,7 @@ static void yaffsfs_RemoveObjectCallback(yaffs_obj_t *obj) yaffs_DIR *yaffs_opendir(const YCHAR *dirname) { yaffs_DIR *dir = NULL; - yaffs_obj_t *obj = NULL; + struct yaffs_obj *obj = NULL; yaffsfs_DirectorySearchContext *dsc = NULL; yaffsfs_Lock(); @@ -2159,12 +2159,12 @@ yaffs_DIR *yaffs_opendir(const YCHAR *dirname) dsc->magic = YAFFS_MAGIC; dsc->dirObj = obj; yaffs_strncpy(dsc->name,dirname,NAME_MAX); - YINIT_LIST_HEAD(&dsc->others); + INIT_LIST_HEAD(&dsc->others); if(!search_contexts.next) - YINIT_LIST_HEAD(&search_contexts); + INIT_LIST_HEAD(&search_contexts); - ylist_add(&dsc->others,&search_contexts); + list_add(&dsc->others,&search_contexts); yaffsfs_SetDirRewound(dsc); } @@ -2227,7 +2227,7 @@ int yaffs_closedir(yaffs_DIR *dirp) yaffsfs_Lock(); dsc->magic = 0; - ylist_del(&dsc->others); /* unhook from list */ + list_del(&dsc->others); /* unhook from list */ YFREE(dsc); yaffsfs_Unlock(); return 0; @@ -2238,8 +2238,8 @@ int yaffs_closedir(yaffs_DIR *dirp) int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath) { - yaffs_obj_t *parent = NULL; - yaffs_obj_t *obj; + struct yaffs_obj *parent = NULL; + struct yaffs_obj *obj; YCHAR *name; int retVal= -1; int mode = 0; /* ignore for now */ @@ -2269,7 +2269,7 @@ int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath) int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz) { - yaffs_obj_t *obj = NULL; + struct yaffs_obj *obj = NULL; int retVal; @@ -2296,8 +2296,8 @@ int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz) int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath) { /* Creates a link called newpath to existing oldpath */ - yaffs_obj_t *obj = NULL; - yaffs_obj_t *target = NULL; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *target = NULL; int retVal = 0; int new_nameLength = 0; @@ -2317,8 +2317,8 @@ int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath) yaffsfs_SetError(-EEXIST); retVal = -1; } else { - yaffs_obj_t *newdir = NULL; - yaffs_obj_t *link = NULL; + struct yaffs_obj *newdir = NULL; + struct yaffs_obj *link = NULL; YCHAR *newname; @@ -2371,7 +2371,7 @@ int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev) */ int yaffs_n_handles(const YCHAR *path) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; obj = yaffsfs_FindObject(NULL,path,0,1); @@ -2388,10 +2388,10 @@ int yaffs_dump_dev(const YCHAR *path) #if 0 YCHAR *rest; - yaffs_obj_t *obj = yaffsfs_FindRoot(path,&rest); + struct yaffs_obj *obj = yaffsfs_FindRoot(path,&rest); if(obj){ - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; printf("\n" "n_page_writes.......... %d\n" diff --git a/direct/yaffsfs.h b/direct/yaffsfs.h index a269ed2..50b5cbc 100644 --- a/direct/yaffsfs.h +++ b/direct/yaffsfs.h @@ -166,8 +166,8 @@ int yaffs_n_handles(const YCHAR *path); int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int shareMode) ; -struct yaffs_dev_s; -void yaffs_add_device(struct yaffs_dev_s *dev); +struct yaffs_dev; +void yaffs_add_device(struct yaffs_dev *dev); int yaffs_start_up(void); int yaffsfs_GetLastError(void); diff --git a/direct/ydirectenv.h b/direct/ydirectenv.h index 824ce20..ee6e8f5 100644 --- a/direct/ydirectenv.h +++ b/direct/ydirectenv.h @@ -43,6 +43,11 @@ #define yaffs_sprintf sprintf #define yaffs_toupper(a) toupper(a) +void yaffs_qsort(void *aa, size_t n, size_t es, + int (*cmp)(const void *, const void *)); + +#define yaffs_sort(base, n, sz, cmp_fn) yaffs_qsort(base, n, sz, cmp_fn) + #define YAFFS_PATH_DIVIDERS "/" #ifdef NO_Y_INLINE @@ -87,6 +92,9 @@ #define yaffs_sum_cmp(x,y) ((x) == (y)) #define yaffs_strcmp(a,b) strcmp(a,b) +#include "yaffs_list.h" + + #include "yaffsfs.h" #endif diff --git a/direct/yportenv.h b/direct/yportenv.h new file mode 100644 index 0000000..22afb06 --- /dev/null +++ b/direct/yportenv.h @@ -0,0 +1,352 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + + +#ifndef __YPORTENV_H__ +#define __YPORTENV_H__ + +/* + * Define the MTD version in terms of Linux Kernel versions + * This allows yaffs to be used independantly of the kernel + * as well as with it. + */ + + +#if defined CONFIG_YAFFS_WINCE + +#include "ywinceenv.h" + + +#elif defined CONFIG_YAFFS_DIRECT + +/* Direct interface */ +#include "ydirectenv.h" + +#elif defined CONFIG_YAFFS_UTIL + +/* Stuff for YAFFS utilities */ + +#include "stdlib.h" +#include "stdio.h" +#include "string.h" + + +#define YMALLOC(x) malloc(x) +#define YFREE(x) free(x) +#define YMALLOC_ALT(x) malloc(x) +#define YFREE_ALT(x) free(x) + +#define YCHAR char +#define YUCHAR unsigned char +#define _Y(x) x +#define yaffs_strcat(a, b) strcat(a, b) +#define yaffs_strcpy(a, b) strcpy(a, b) +#define yaffs_strncpy(a, b, c) strncpy(a, b, c) +#define yaffs_strnlen(s,m) strnlen(s,m) +#define yaffs_sprintf sprintf +#define yaffs_toupper(a) toupper(a) + +#define Y_INLINE inline + +/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */ +/* #define YALERT(s) YINFO(s) */ + +#define TENDSTR "\n" +#define TSTR(x) x +#define TOUT(p) printf p + +#define YAFFS_LOSTNFOUND_NAME "lost+found" +#define YAFFS_LOSTNFOUND_PREFIX "obj" +/* #define YPRINTF(x) printf x */ + +#define YAFFS_ROOT_MODE 0755 +#define YAFFS_LOSTNFOUND_MODE 0700 + +#define yaffs_sum_cmp(x, y) ((x) == (y)) +#define yaffs_strcmp(a, b) strcmp(a, b) + +#else +/* Should have specified a configuration type */ +#error Unknown configuration + +#endif + +#if defined(CONFIG_YAFFS_DIRECT) || defined(CONFIG_YAFFS_WINCE) + +#ifdef CONFIG_YAFFSFS_PROVIDE_VALUES + +#ifndef O_RDONLY +#define O_RDONLY 00 +#endif + +#ifndef O_WRONLY +#define O_WRONLY 01 +#endif + +#ifndef O_RDWR +#define O_RDWR 02 +#endif + +#ifndef O_CREAT +#define O_CREAT 0100 +#endif + +#ifndef O_EXCL +#define O_EXCL 0200 +#endif + +#ifndef O_TRUNC +#define O_TRUNC 01000 +#endif + +#ifndef O_APPEND +#define O_APPEND 02000 +#endif + +#ifndef SEEK_SET +#define SEEK_SET 0 +#endif + +#ifndef SEEK_CUR +#define SEEK_CUR 1 +#endif + +#ifndef SEEK_END +#define SEEK_END 2 +#endif + +#ifndef EBUSY +#define EBUSY 16 +#endif + +#ifndef ENODEV +#define ENODEV 19 +#endif + +#ifndef EINVAL +#define EINVAL 22 +#endif + +#ifndef ENFILE +#define ENFILE 23 +#endif + +#ifndef EBADF +#define EBADF 9 +#endif + +#ifndef EACCES +#define EACCES 13 +#endif + +#ifndef EXDEV +#define EXDEV 18 +#endif + +#ifndef ENOENT +#define ENOENT 2 +#endif + +#ifndef ENOSPC +#define ENOSPC 28 +#endif + +#ifndef ERANGE +#define ERANGE 34 +#endif + +#ifndef ENODATA +#define ENODATA 61 +#endif + +#ifndef ENOTEMPTY +#define ENOTEMPTY 39 +#endif + +#ifndef ENAMETOOLONG +#define ENAMETOOLONG 36 +#endif + +#ifndef ENOMEM +#define ENOMEM 12 +#endif + +#ifndef EEXIST +#define EEXIST 17 +#endif + +#ifndef ENOTDIR +#define ENOTDIR 20 +#endif + +#ifndef EISDIR +#define EISDIR 21 +#endif + + +// Mode flags + +#ifndef S_IFMT +#define S_IFMT 0170000 +#endif + +#ifndef S_IFLNK +#define S_IFLNK 0120000 +#endif + +#ifndef S_IFDIR +#define S_IFDIR 0040000 +#endif + +#ifndef S_IFREG +#define S_IFREG 0100000 +#endif + +#ifndef S_IREAD +#define S_IREAD 0000400 +#endif + +#ifndef S_IWRITE +#define S_IWRITE 0000200 +#endif + +#ifndef S_IEXEC +#define S_IEXEC 0000100 +#endif + +#ifndef XATTR_CREATE +#define XATTR_CREATE 1 +#endif + +#ifndef XATTR_REPLACE +#define XATTR_REPLACE 2 +#endif + +#ifndef R_OK +#define R_OK 4 +#define W_OK 2 +#define X_OK 1 +#define F_OK 0 +#endif + +#else +#include +#include +#include +#endif + +#endif + +#ifndef Y_DUMP_STACK +#define Y_DUMP_STACK() do { } while (0) +#endif + +#ifndef YBUG +#define YBUG() do {\ + T(YAFFS_TRACE_BUG,\ + (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),\ + __LINE__));\ + Y_DUMP_STACK();\ +} while (0) +#endif + + +#endif + +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +/* + * This file is just holds extra declarations of macros that would normally + * be provided in the Linux kernel. These macros have been written from + * scratch but are functionally equivalent to the Linux ones. + * + */ + +#ifndef __EXTRAS_H__ +#define __EXTRAS_H__ + + +/* Definition of types */ +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned u32; + + +#ifndef WIN32 +#include +#endif + + +#ifdef CONFIG_YAFFS_PROVIDE_DEFS +/* File types */ + + +#define DT_UNKNOWN 0 +#define DT_FIFO 1 +#define DT_CHR 2 +#define DT_DIR 4 +#define DT_BLK 6 +#define DT_REG 8 +#define DT_LNK 10 +#define DT_SOCK 12 +#define DT_WHT 14 + + +#ifndef WIN32 +#include +#endif + +/* + * Attribute flags. These should be or-ed together to figure out what + * has been changed! + */ +#define ATTR_MODE 1 +#define ATTR_UID 2 +#define ATTR_GID 4 +#define ATTR_SIZE 8 +#define ATTR_ATIME 16 +#define ATTR_MTIME 32 +#define ATTR_CTIME 64 + +struct iattr { + unsigned int ia_valid; + unsigned ia_mode; + unsigned ia_uid; + unsigned ia_gid; + unsigned ia_size; + unsigned ia_atime; + unsigned ia_mtime; + unsigned ia_ctime; + unsigned int ia_attr_flags; +}; + +#endif + + + +#endif diff --git a/moduleconfig.h b/moduleconfig.h index 4b4d642..20a0882 100644 --- a/moduleconfig.h +++ b/moduleconfig.h @@ -62,7 +62,6 @@ /* Meaning: Select to disable background processing */ /* #define CONFIG_DISABLE_BACKGROUND */ - /* Default: Selected */ /* Meaning: Enable XATTR support */ #define CONFIG_YAFFS_XATTR diff --git a/mtdemul/nandemul2k.c b/mtdemul/nandemul2k.c index 862b244..4cba57b 100644 --- a/mtdemul/nandemul2k.c +++ b/mtdemul/nandemul2k.c @@ -66,7 +66,7 @@ static struct mtd_info nandemul2k_mtd; typedef struct { - __u8 data[PAGE_TOTAL_SIZE]; // Data + spare + u8 data[PAGE_TOTAL_SIZE]; // Data + spare int empty; // is this empty? } nandemul_Page; @@ -114,8 +114,8 @@ static void nandemul2k_Program(const void *buffer, int page, int start, int n_by { int pg = page%PAGES_PER_BLOCK; int blk = page/PAGES_PER_BLOCK; - __u8 *p; - __u8 *b = (__u8 *)buffer; + u8 *p; + u8 *b = (u8 *)buffer; p = &ned.block[blk]->page[pg]->data[start]; @@ -255,7 +255,7 @@ int nandemul2k_GetNumberOfBlocks(void) {return nandemul2k_CalcNBlocks();} -static int nandemul2k_ReadId(__u8 *vendorId, __u8 *deviceId) +static int nandemul2k_ReadId(u8 *vendorId, u8 *deviceId) { *vendorId = 'Y'; *deviceId = '2'; @@ -264,7 +264,7 @@ static int nandemul2k_ReadId(__u8 *vendorId, __u8 *deviceId) } -static int nandemul2k_ReadStatus(__u8 *status) +static int nandemul2k_ReadStatus(u8 *status) { *status = 0; return 1; diff --git a/patch-ker.sh b/patch-ker.sh index 5894087..ba6b6e4 100755 --- a/patch-ker.sh +++ b/patch-ker.sh @@ -53,9 +53,16 @@ else fi if [ $MULTIORSINGLE = m ]; then - VFSGLUE="yaffs_vfs_multi.c" + VFS_CODE="yaffs_vfs_multi.c" + MTD1_CODE="yaffs_mtdif1_multi.c" + MTD2_CODE="yaffs_mtdif2_multi.c" + YPORTENV="yportenv_multi.h" elif [ $MULTIORSINGLE = s ]; then - VFSGLUE="yaffs_vfs.c" + VFS_CODE="yaffs_vfs_single.c" + MTD1_CODE="yaffs_mtdif1_single.c" + MTD2_CODE="yaffs_mtdif2_single.c" + YPORTENV="yportenv_single.h" + echo "" echo "*** Warning ***" echo "You have chosen to use the single kernel variant of the yaffs VFS glue code" @@ -112,17 +119,17 @@ else echo "Updating $KCONFIG" mv -f $KCONFIG $KCONFIGOLD sed -n -e "/[Jj][Ff][Ff][Ss]/,99999 ! p" $KCONFIGOLD >$KCONFIG - echo "">>$KCONFIG - echo "# Patched by YAFFS" >>$KCONFIG + # echo "">>$KCONFIG + # echo "# Patched by YAFFS" >>$KCONFIG echo "source \"fs/yaffs2/Kconfig\"">>$KCONFIG - echo "">>$KCONFIG + # echo "">>$KCONFIG sed -n -e "/[Jj][Ff][Ff][Ss]/,99999 p" $KCONFIGOLD >>$KCONFIG # now do fs/Makefile -- simply add the target at the end echo "Updating $MAKEFILE" cp -f $MAKEFILE $MAKEFILEOLD - echo "">>$MAKEFILE - echo "# Patched by YAFFS" >>$MAKEFILE + # echo "">>$MAKEFILE + # echo "# Patched by YAFFS" >>$MAKEFILE echo "obj-\$(CONFIG_YAFFS_FS) += yaffs2/" >>$MAKEFILE fi @@ -135,10 +142,16 @@ then echo "already there then delete $YAFFSDIR and re-run this script" echo " eg. \"rm -rf $YAFFSDIR\" " else + rm yaffs*.mod.c mkdir $LINUXDIR/fs/yaffs2 $CPY $PWD/Makefile.kernel $LINUXDIR/fs/yaffs2/Makefile $CPY $PWD/Kconfig $LINUXDIR/fs/yaffs2 $CPY $PWD/*.c $PWD/*.h $LINUXDIR/fs/yaffs2 - rm $LINUXDIR/fs/yaffs2/yaffs_vfs.c $LINUXDIR/fs/yaffs2/yaffs_vfs_multi.c - $CPY $PWD/$VFSGLUE $LINUXDIR/fs/yaffs2/yaffs_vfs_glue.c + rm $LINUXDIR/fs/yaffs2/yaffs_vfs*.c $LINUXDIR/fs/yaffs2/yaffs_mtdif[12]*.c + rm $LINUXDIR/fs/yaffs2/yportenv*.h + rm $LINUXDIR/fs/yaffs2/moduleconfig.h + $CPY $PWD/$VFS_CODE $LINUXDIR/fs/yaffs2/yaffs_vfs.c + $CPY $PWD/$MTD1_CODE $LINUXDIR/fs/yaffs2/yaffs_mtdif1.c + $CPY $PWD/$MTD2_CODE $LINUXDIR/fs/yaffs2/yaffs_mtdif2.c + $CPY $PWD/$YPORTENV $LINUXDIR/fs/yaffs2/yportenv.h fi diff --git a/yaffs_linux_allocator.c b/patches/yaffs_linux_allocator.c similarity index 90% rename from yaffs_linux_allocator.c rename to patches/yaffs_linux_allocator.c index d0837f8..b538776 100644 --- a/yaffs_linux_allocator.c +++ b/patches/yaffs_linux_allocator.c @@ -42,7 +42,7 @@ typedef struct yaffs_AllocatorStruct yaffs_Allocator; int mount_id; -void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev) { yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; @@ -102,10 +102,10 @@ static void (*fake_ctor_list[10]) (void *) = { fake_ctor9, }; -void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) { yaffs_Allocator *allocator; - unsigned mount_id = yaffs_dev_to_lc(dev)->mount_id; + unsigned mount_id = struct yaffs_devo_lc(dev)->mount_id; T(YAFFS_TRACE_ALLOCATE,(TSTR("Initialising yaffs allocator\n"))); @@ -147,7 +147,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) allocator->object_cache = kmem_cache_create(allocator->object_name, - sizeof(yaffs_obj_t), + sizeof(struct yaffs_obj), 0, 0, fake_ctor_list[mount_id]); @@ -165,7 +165,7 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) } -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev) { yaffs_Allocator *allocator = dev->allocator; if(!allocator || !allocator->tnode_cache){ @@ -175,13 +175,13 @@ yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) return kmem_cache_alloc(allocator->tnode_cache, GFP_NOFS); } -void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { yaffs_Allocator *allocator = dev->allocator; kmem_cache_free(allocator->tnode_cache,tn); } -yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) { yaffs_Allocator *allocator = dev->allocator; if(!allocator){ @@ -195,7 +195,7 @@ yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) return kmem_cache_alloc(allocator->object_cache, GFP_NOFS); } -void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) { yaffs_Allocator *allocator = dev->allocator; kmem_cache_free(allocator->object_cache,obj); diff --git a/patches/yaffs_mtdif2.c b/patches/yaffs_mtdif2.c index c105e45..19677ad 100644 --- a/patches/yaffs_mtdif2.c +++ b/patches/yaffs_mtdif2.c @@ -28,10 +28,10 @@ const char *yaffs_mtdif2_c_version = #include "yaffs_packedtags2.h" -void nandmtd2_pt2buf(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw) +void nandmtd2_pt2buf(struct yaffs_dev *dev, yaffs_PackedTags2 *pt, int is_raw) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); - __u8 *ptab = (__u8 *)pt; /* packed tags as bytes */ + u8 *ptab = (u8 *)pt; /* packed tags as bytes */ int i, j = 0, k, n; @@ -69,11 +69,11 @@ void nandmtd2_pt2buf(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw) } -void nandmtd2_buf2pt(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw) +void nandmtd2_buf2pt(struct yaffs_dev *dev, yaffs_PackedTags2 *pt, int is_raw) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); int i, j = 0, k, n; - __u8 *ptab = (__u8 *)pt; /* packed tags as bytes */ + u8 *ptab = (u8 *)pt; /* packed tags as bytes */ if (!is_raw) { @@ -107,9 +107,9 @@ void nandmtd2_buf2pt(yaffs_dev_t *dev, yaffs_PackedTags2 *pt, int is_raw) } -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, - const __u8 * data, - const yaffs_ext_tags * tags) +int nandmtd2_WriteChunkWithTagsToNAND(struct yaffs_dev * dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags * tags) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); size_t dummy; @@ -149,8 +149,8 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_dev_t * dev, int nand_chunk, return YAFFS_FAIL; } -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, - __u8 * data, yaffs_ext_tags * tags) +int nandmtd2_ReadChunkWithTagsFromNAND(struct yaffs_dev * dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags * tags) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); size_t dummy; @@ -193,7 +193,7 @@ int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_dev_t * dev, int nand_chunk, return YAFFS_FAIL; } -int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) +int nandmtd2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); int retval; @@ -212,8 +212,8 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_dev_s *dev, int block_no) } -int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, - yaffs_block_state_t * state, int *seq_number) +int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state * state, int *seq_number) { struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); int retval; @@ -231,7 +231,7 @@ int nandmtd2_QueryNANDBlock(struct yaffs_dev_s *dev, int block_no, *state = YAFFS_BLOCK_STATE_DEAD; *seq_number = 0; } else { - yaffs_ext_tags t; + struct yaffs_ext_tags t; nandmtd2_ReadChunkWithTagsFromNAND(dev, block_no * dev->chunks_per_block, NULL, diff --git a/utils/mkyaffs2image.c b/utils/mkyaffs2image.c index 2d63908..fa2229b 100644 --- a/utils/mkyaffs2image.c +++ b/utils/mkyaffs2image.c @@ -143,11 +143,11 @@ static int find_obj_in_list(dev_t dev, ino_t ino) * NOTE: The tag is not usable after this other than calculating the CRC * with. */ -static void little_to_big_endian(yaffs_ext_tags *tagsPtr) +static void little_to_big_endian(struct yaffs_ext_tags *tagsPtr) { #if 0 // FIXME NCB - yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes. - yaffs_tags_union_t temp; + union yaffs_tags_union * tags = (union yaffs_tags_union* )tagsPtr; // Work in bytes. + union yaffs_tags_union temp; memset(&temp, 0, sizeof(temp)); // Ick, I hate magic numbers. @@ -172,17 +172,17 @@ static void little_to_big_endian(yaffs_ext_tags *tagsPtr) #endif } -static void shuffle_oob(char *spareData, yaffs_packed_tags2 *pt) +static void shuffle_oob(char *spareData, struct yaffs_packed_tags2 *pt) { assert(sizeof(*pt) <= spareSize); // NAND LAYOUT: For non-trivial OOB orderings, here would be a good place to shuffle. memcpy(spareData, pt, sizeof(*pt)); } -static int write_chunk(__u8 *data, __u32 id, __u32 chunk_id, __u32 n_bytes) +static int write_chunk(u8 *data, u32 id, u32 chunk_id, u32 n_bytes) { - yaffs_ext_tags t; - yaffs_packed_tags2 pt; + struct yaffs_ext_tags t; + struct yaffs_packed_tags2 pt; char spareData[spareSize]; if (write(outFile,data,chunkSize) != chunkSize) @@ -228,12 +228,12 @@ static int write_chunk(__u8 *data, __u32 id, __u32 chunk_id, __u32 n_bytes) (((x) & 0xFF00) >> 8)) // This one is easier, since the types are more standard. No funky shifts here. -static void object_header_little_to_big_endian(yaffs_obj_header* oh) +static void object_header_little_to_big_endian(struct yaffs_obj_hdr* oh) { int i; oh->type = SWAP32(oh->type); // GCC makes enums 32 bits. oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int - oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // __u16 - Not used, but done for completeness. + oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // u16 - Not used, but done for completeness. // name = skip. Char array. Not swapped. oh->yst_mode = SWAP32(oh->yst_mode); #ifdef CONFIG_YAFFS_WINCE // WinCE doesn't implement this, but we need to just in case. @@ -276,12 +276,12 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh) #endif } -static int write_object_header(int id, yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias) +static int write_object_header(int id, enum yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias) { - __u8 bytes[chunkSize]; + u8 bytes[chunkSize]; - yaffs_obj_header *oh = (yaffs_obj_header *)bytes; + struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)bytes; memset(bytes,0xff,sizeof(bytes)); @@ -342,7 +342,7 @@ static int write_object_header(int id, yaffs_obj_type t, struct stat *s, int par static void pad_image(void) { - __u8 data[chunkSize + spareSize]; + u8 data[chunkSize + spareSize]; int padPages = (nPages % pagesPerBlock); if (padPages) @@ -444,7 +444,7 @@ static int process_directory(int parent, const char *path) if(write_object_header(newObj, YAFFS_OBJECT_TYPE_FILE, &stats, parent, entry->d_name, -1, NULL) == 0) { int h; - __u8 bytes[chunkSize]; + u8 bytes[chunkSize]; int n_bytes; int chunk = 0; diff --git a/utils/mkyaffsimage.c b/utils/mkyaffsimage.c index 94b0298..02ad521 100644 --- a/utils/mkyaffsimage.c +++ b/utils/mkyaffsimage.c @@ -113,12 +113,12 @@ static int find_obj_in_list(dev_t dev, ino_t ino) } // NCB added 10/9/2002 -static __u16 yaffs_calc_name_sum(const char *name) +static u16 yaffs_calc_name_sum(const char *name) { - __u16 sum = 0; - __u16 i = 1; + u16 sum = 0; + u16 i = 1; - __u8 *bname = (__u8 *)name; + u8 *bname = (u8 *)name; while (*bname) { @@ -130,16 +130,16 @@ static __u16 yaffs_calc_name_sum(const char *name) } -static void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare) +static void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare) { yaffs_ecc_cacl(data , spare->ecc1); yaffs_ecc_cacl(&data[256] , spare->ecc2); } -static void yaffs_calc_tags_ecc(yaffs_tags_t *tags) +static void yaffs_calc_tags_ecc(struct yaffs_tags *tags) { // Todo don't do anything yet. Need to calculate ecc - unsigned char *b = ((yaffs_tags_union_t *)tags)->as_bytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; unsigned i,j; unsigned ecc = 0; unsigned bit = 0; @@ -181,9 +181,9 @@ static void yaffs_calc_tags_ecc(yaffs_tags_t *tags) b[7] |= ((ecc & 0x3F) << 2); } } -static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, yaffs_tags_t *tagsPtr) +static void yaffs_load_tags_to_spare(struct yaffs_spare *sparePtr, struct yaffs_tags *tagsPtr) { - yaffs_tags_union_t *tu = (yaffs_tags_union_t *)tagsPtr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tagsPtr; //yaffs_calc_tags_ecc(tagsPtr); @@ -201,10 +201,10 @@ static void yaffs_load_tags_to_spare(yaffs_spare *sparePtr, yaffs_tags_t *tagsPt * NOTE: The tag is not usable after this other than calculating the CRC * with. */ -static void little_to_big_endian(yaffs_tags_t *tagsPtr) +static void little_to_big_endian(struct yaffs_tags *tagsPtr) { - yaffs_tags_union_t * tags = (yaffs_tags_union_t* )tagsPtr; // Work in bytes. - yaffs_tags_union_t temp; + union yaffs_tags_union * tags = (union yaffs_tags_union* )tagsPtr; // Work in bytes. + union yaffs_tags_union temp; memset(&temp, 0, sizeof(temp)); // Ick, I hate magic numbers. @@ -228,16 +228,16 @@ static void little_to_big_endian(yaffs_tags_t *tagsPtr) tags->as_bytes[7] = temp.as_bytes[7]; } -static int write_chunk(__u8 *data, __u32 obj_id, __u32 chunk_id, __u32 n_bytes) +static int write_chunk(u8 *data, u32 obj_id, u32 chunk_id, u32 n_bytes) { - yaffs_tags_t t; - yaffs_spare s; + struct yaffs_tags t; + struct yaffs_spare s; error = write(outFile,data,512); if(error < 0) return error; - memset(&t,0xff,sizeof (yaffs_tags_t)); - memset(&s,0xff,sizeof (yaffs_spare)); + memset(&t,0xff,sizeof (struct yaffs_tags)); + memset(&s,0xff,sizeof (struct yaffs_spare)); t.chunk_id = chunk_id; t.serial_number = 0; @@ -255,7 +255,7 @@ static int write_chunk(__u8 *data, __u32 obj_id, __u32 chunk_id, __u32 n_bytes) nPages++; - return write(outFile,&s,sizeof(yaffs_spare)); + return write(outFile,&s,sizeof(struct yaffs_spare)); } @@ -268,11 +268,11 @@ static int write_chunk(__u8 *data, __u32 obj_id, __u32 chunk_id, __u32 n_bytes) (((x) & 0xFF00) >> 8)) // This one is easier, since the types are more standard. No funky shifts here. -static void object_header_little_to_big_endian(yaffs_obj_header* oh) +static void object_header_little_to_big_endian(struct yaffs_obj_hdr* oh) { oh->type = SWAP32(oh->type); // GCC makes enums 32 bits. oh->parent_obj_id = SWAP32(oh->parent_obj_id); // int - oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // __u16 - Not used, but done for completeness. + oh->sum_no_longer_used = SWAP16(oh->sum_no_longer_used); // u16 - Not used, but done for completeness. // name = skip. Char array. Not swapped. oh->yst_mode = SWAP32(oh->yst_mode); #ifdef CONFIG_YAFFS_WINCE // WinCE doesn't implement this, but we need to just in case. @@ -325,12 +325,12 @@ static void object_header_little_to_big_endian(yaffs_obj_header* oh) #endif } -static int write_object_header(int obj_id, yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias) +static int write_object_header(int obj_id, enum yaffs_obj_type t, struct stat *s, int parent, const char *name, int equivalentObj, const char * alias) { - __u8 bytes[512]; + u8 bytes[512]; - yaffs_obj_header *oh = (yaffs_obj_header *)bytes; + struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)bytes; memset(bytes,0xff,512); @@ -453,7 +453,7 @@ static int process_directory(int parent, const char *path) if(error >= 0) { int h; - __u8 bytes[512]; + u8 bytes[512]; int n_bytes; int chunk = 0; diff --git a/yaffs_allocator.c b/yaffs_allocator.c index 024ee2a..03ede86 100644 --- a/yaffs_allocator.c +++ b/yaffs_allocator.c @@ -11,8 +11,6 @@ * published by the Free Software Foundation. */ - - #include "yaffs_allocator.h" #include "yaffs_guts.h" #include "yaffs_trace.h" @@ -20,45 +18,44 @@ #ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR -void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev) { dev = dev; } -void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) { dev = dev; } -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev) { - return (yaffs_tnode_t *)YMALLOC(dev->tnode_size); + return (struct yaffs_tnode *)YMALLOC(dev->tnode_size); } -void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { dev = dev; YFREE(tn); } -void yaffs_init_raw_objs(yaffs_dev_t *dev) +void yaffs_init_raw_objs(struct yaffs_dev *dev) { dev = dev; } -void yaffs_deinit_raw_objs(yaffs_dev_t *dev) +void yaffs_deinit_raw_objs(struct yaffs_dev *dev) { dev = dev; } -yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) { dev = dev; - return (yaffs_obj_t *) YMALLOC(sizeof(yaffs_obj_t)); + return (struct yaffs_obj *)YMALLOC(sizeof(struct yaffs_obj)); } - -void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) { dev = dev; @@ -69,85 +66,79 @@ void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) struct yaffs_tnode_list { struct yaffs_tnode_list *next; - yaffs_tnode_t *tnodes; + struct yaffs_tnode *tnodes; }; -typedef struct yaffs_tnode_list yaffs_tnodelist_t; - -struct yaffs_obj_list_struct { - yaffs_obj_t *objects; - struct yaffs_obj_list_struct *next; +struct yaffs_obj_list { + struct yaffs_obj_list *next; + struct yaffs_obj *objects; }; -typedef struct yaffs_obj_list_struct yaffs_obj_list; +struct yaffs_allocator { + int n_tnodes_created; + struct yaffs_tnode *free_tnodes; + int n_free_tnodes; + struct yaffs_tnode_list *alloc_tnode_list; + int n_obj_created; + struct yaffs_obj *free_objs; + int n_free_objects; -struct yaffs_AllocatorStruct { - int n_tnodesCreated; - yaffs_tnode_t *freeTnodes; - int nFreeTnodes; - yaffs_tnodelist_t *allocatedTnodeList; - - int n_objCreated; - yaffs_obj_t *freeObjects; - int nFreeObjects; - - yaffs_obj_list *allocated_list; + struct yaffs_obj_list *allocated_obj_list; }; -typedef struct yaffs_AllocatorStruct yaffs_Allocator; - - -static void yaffs_deinit_raw_tnodes(yaffs_dev_t *dev) +static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; - yaffs_tnodelist_t *tmp; + struct yaffs_tnode_list *tmp; - if(!allocator){ + if (!allocator) { YBUG(); return; } - while (allocator->allocatedTnodeList) { - tmp = allocator->allocatedTnodeList->next; + while (allocator->alloc_tnode_list) { + tmp = allocator->alloc_tnode_list->next; - YFREE(allocator->allocatedTnodeList->tnodes); - YFREE(allocator->allocatedTnodeList); - allocator->allocatedTnodeList = tmp; + YFREE(allocator->alloc_tnode_list->tnodes); + YFREE(allocator->alloc_tnode_list); + allocator->alloc_tnode_list = tmp; } - allocator->freeTnodes = NULL; - allocator->nFreeTnodes = 0; - allocator->n_tnodesCreated = 0; + allocator->free_tnodes = NULL; + allocator->n_free_tnodes = 0; + allocator->n_tnodes_created = 0; } -static void yaffs_init_raw_tnodes(yaffs_dev_t *dev) +static void yaffs_init_raw_tnodes(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(allocator){ - allocator->allocatedTnodeList = NULL; - allocator->freeTnodes = NULL; - allocator->nFreeTnodes = 0; - allocator->n_tnodesCreated = 0; + if (allocator) { + allocator->alloc_tnode_list = NULL; + allocator->free_tnodes = NULL; + allocator->n_free_tnodes = 0; + allocator->n_tnodes_created = 0; } else YBUG(); } -static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes) +static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) { - yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; int i; - yaffs_tnode_t *newTnodes; - __u8 *mem; - yaffs_tnode_t *curr; - yaffs_tnode_t *next; - yaffs_tnodelist_t *tnl; + struct yaffs_tnode *new_tnodes; + u8 *mem; + struct yaffs_tnode *curr; + struct yaffs_tnode *next; + struct yaffs_tnode_list *tnl; - if(!allocator){ + if (!allocator) { YBUG(); return YAFFS_FAIL; } @@ -155,47 +146,46 @@ static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes) if (n_tnodes < 1) return YAFFS_OK; - /* make these things */ - newTnodes = YMALLOC(n_tnodes * dev->tnode_size); - mem = (__u8 *)newTnodes; + new_tnodes = YMALLOC(n_tnodes * dev->tnode_size); + mem = (u8 *) new_tnodes; - if (!newTnodes) { + if (!new_tnodes) { T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); + (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); return YAFFS_FAIL; } /* New hookup for wide tnodes */ for (i = 0; i < n_tnodes - 1; i++) { - curr = (yaffs_tnode_t *) &mem[i * dev->tnode_size]; - next = (yaffs_tnode_t *) &mem[(i+1) * dev->tnode_size]; + curr = (struct yaffs_tnode *)&mem[i * dev->tnode_size]; + next = (struct yaffs_tnode *)&mem[(i + 1) * dev->tnode_size]; curr->internal[0] = next; } - curr = (yaffs_tnode_t *) &mem[(n_tnodes - 1) * dev->tnode_size]; - curr->internal[0] = allocator->freeTnodes; - allocator->freeTnodes = (yaffs_tnode_t *)mem; + curr = (struct yaffs_tnode *)&mem[(n_tnodes - 1) * dev->tnode_size]; + curr->internal[0] = allocator->free_tnodes; + allocator->free_tnodes = (struct yaffs_tnode *)mem; - allocator->nFreeTnodes += n_tnodes; - allocator->n_tnodesCreated += n_tnodes; + allocator->n_free_tnodes += n_tnodes; + allocator->n_tnodes_created += n_tnodes; /* Now add this bunch of tnodes to a list for freeing up. * NB If we can't add this to the management list it isn't fatal * but it just means we can't free this bunch of tnodes later. */ - tnl = YMALLOC(sizeof(yaffs_tnodelist_t)); + tnl = YMALLOC(sizeof(struct yaffs_tnode_list)); if (!tnl) { T(YAFFS_TRACE_ERROR, (TSTR ("yaffs: Could not add tnodes to management list" TENDSTR))); - return YAFFS_FAIL; + return YAFFS_FAIL; } else { - tnl->tnodes = newTnodes; - tnl->next = allocator->allocatedTnodeList; - allocator->allocatedTnodeList = tnl; + tnl->tnodes = new_tnodes; + tnl->next = allocator->alloc_tnode_list; + allocator->alloc_tnode_list = tnl; } T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR))); @@ -203,95 +193,92 @@ static int yaffs_create_tnodes(yaffs_dev_t *dev, int n_tnodes) return YAFFS_OK; } - -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev) +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; - yaffs_tnode_t *tn = NULL; + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; + struct yaffs_tnode *tn = NULL; - if(!allocator){ + if (!allocator) { YBUG(); return NULL; } /* If there are none left make more */ - if (!allocator->freeTnodes) + if (!allocator->free_tnodes) yaffs_create_tnodes(dev, YAFFS_ALLOCATION_NTNODES); - if (allocator->freeTnodes) { - tn = allocator->freeTnodes; - allocator->freeTnodes = allocator->freeTnodes->internal[0]; - allocator->nFreeTnodes--; + if (allocator->free_tnodes) { + tn = allocator->free_tnodes; + allocator->free_tnodes = allocator->free_tnodes->internal[0]; + allocator->n_free_tnodes--; } return tn; } /* FreeTnode frees up a tnode and puts it back on the free list */ -void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(!allocator){ + if (!allocator) { YBUG(); return; } if (tn) { - tn->internal[0] = allocator->freeTnodes; - allocator->freeTnodes = tn; - allocator->nFreeTnodes++; + tn->internal[0] = allocator->free_tnodes; + allocator->free_tnodes = tn; + allocator->n_free_tnodes++; } - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ } - - -static void yaffs_init_raw_objs(yaffs_dev_t *dev) +static void yaffs_init_raw_objs(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(allocator) { - allocator->allocated_list = NULL; - allocator->freeObjects = NULL; - allocator->nFreeObjects = 0; + if (allocator) { + allocator->allocated_obj_list = NULL; + allocator->free_objs = NULL; + allocator->n_free_objects = 0; } else YBUG(); } -static void yaffs_deinit_raw_objs(yaffs_dev_t *dev) +static void yaffs_deinit_raw_objs(struct yaffs_dev *dev) { - yaffs_Allocator *allocator = dev->allocator; - yaffs_obj_list *tmp; + struct yaffs_allocator *allocator = dev->allocator; + struct yaffs_obj_list *tmp; - if(!allocator){ + if (!allocator) { YBUG(); return; } - while (allocator->allocated_list) { - tmp = allocator->allocated_list->next; - YFREE(allocator->allocated_list->objects); - YFREE(allocator->allocated_list); + while (allocator->allocated_obj_list) { + tmp = allocator->allocated_obj_list->next; + YFREE(allocator->allocated_obj_list->objects); + YFREE(allocator->allocated_obj_list); - allocator->allocated_list = tmp; + allocator->allocated_obj_list = tmp; } - allocator->freeObjects = NULL; - allocator->nFreeObjects = 0; - allocator->n_objCreated = 0; + allocator->free_objs = NULL; + allocator->n_free_objects = 0; + allocator->n_obj_created = 0; } - -static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj) +static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; int i; - yaffs_obj_t *newObjects; - yaffs_obj_list *list; + struct yaffs_obj *new_objs; + struct yaffs_obj_list *list; - if(!allocator){ + if (!allocator) { YBUG(); return YAFFS_FAIL; } @@ -300,15 +287,15 @@ static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj) return YAFFS_OK; /* make these things */ - newObjects = YMALLOC(n_obj * sizeof(yaffs_obj_t)); - list = YMALLOC(sizeof(yaffs_obj_list)); + new_objs = YMALLOC(n_obj * sizeof(struct yaffs_obj)); + list = YMALLOC(sizeof(struct yaffs_obj_list)); - if (!newObjects || !list) { - if (newObjects){ - YFREE(newObjects); - newObjects = NULL; + if (!new_objs || !list) { + if (new_objs) { + YFREE(new_objs); + new_objs = NULL; } - if (list){ + if (list) { YFREE(list); list = NULL; } @@ -319,83 +306,82 @@ static int yaffs_create_free_objs(yaffs_dev_t *dev, int n_obj) /* Hook them into the free list */ for (i = 0; i < n_obj - 1; i++) { - newObjects[i].siblings.next = - (struct ylist_head *)(&newObjects[i + 1]); + new_objs[i].siblings.next = + (struct list_head *)(&new_objs[i + 1]); } - newObjects[n_obj - 1].siblings.next = (void *)allocator->freeObjects; - allocator->freeObjects = newObjects; - allocator->nFreeObjects += n_obj; - allocator->n_objCreated += n_obj; + new_objs[n_obj - 1].siblings.next = (void *)allocator->free_objs; + allocator->free_objs = new_objs; + allocator->n_free_objects += n_obj; + allocator->n_obj_created += n_obj; /* Now add this bunch of Objects to a list for freeing up. */ - list->objects = newObjects; - list->next = allocator->allocated_list; - allocator->allocated_list = list; + list->objects = new_objs; + list->next = allocator->allocated_obj_list; + allocator->allocated_obj_list = list; return YAFFS_OK; } -yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev) +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) { - yaffs_obj_t *obj = NULL; - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_obj *obj = NULL; + struct yaffs_allocator *allocator = dev->allocator; - if(!allocator) { + if (!allocator) { YBUG(); return obj; } /* If there are none left make more */ - if (!allocator->freeObjects) + if (!allocator->free_objs) yaffs_create_free_objs(dev, YAFFS_ALLOCATION_NOBJECTS); - if (allocator->freeObjects) { - obj = allocator->freeObjects; - allocator->freeObjects = - (yaffs_obj_t *) (allocator->freeObjects->siblings.next); - allocator->nFreeObjects--; + if (allocator->free_objs) { + obj = allocator->free_objs; + allocator->free_objs = + (struct yaffs_obj *)(allocator->free_objs->siblings.next); + allocator->n_free_objects--; } return obj; } - -void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj) +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) { - yaffs_Allocator *allocator = dev->allocator; + struct yaffs_allocator *allocator = dev->allocator; - if(!allocator) + if (!allocator) YBUG(); else { /* Link into the free list. */ - obj->siblings.next = (struct ylist_head *)(allocator->freeObjects); - allocator->freeObjects = obj; - allocator->nFreeObjects++; + obj->siblings.next = (struct list_head *)(allocator->free_objs); + allocator->free_objs = obj; + allocator->n_free_objects++; } } -void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev) +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev) { - if(dev->allocator){ + if (dev->allocator) { yaffs_deinit_raw_tnodes(dev); yaffs_deinit_raw_objs(dev); YFREE(dev->allocator); - dev->allocator=NULL; + dev->allocator = NULL; } else YBUG(); } -void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) { - yaffs_Allocator *allocator; + struct yaffs_allocator *allocator; - if(!dev->allocator){ - allocator = YMALLOC(sizeof(yaffs_Allocator)); - if(allocator){ + if (!dev->allocator) { + allocator = YMALLOC(sizeof(struct yaffs_allocator)); + if (allocator) { dev->allocator = allocator; yaffs_init_raw_tnodes(dev); yaffs_init_raw_objs(dev); @@ -404,5 +390,4 @@ void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev) YBUG(); } - #endif diff --git a/yaffs_allocator.h b/yaffs_allocator.h index 777f3b0..4d5f2ae 100644 --- a/yaffs_allocator.h +++ b/yaffs_allocator.h @@ -18,13 +18,13 @@ #include "yaffs_guts.h" -void yaffs_init_raw_tnodes_and_objs(yaffs_dev_t *dev); -void yaffs_deinit_raw_tnodes_and_objs(yaffs_dev_t *dev); +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev); +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev); -yaffs_tnode_t *yaffs_alloc_raw_tnode(yaffs_dev_t *dev); -void yaffs_free_raw_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn); +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev); +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn); -yaffs_obj_t *yaffs_alloc_raw_obj(yaffs_dev_t *dev); -void yaffs_free_raw_obj(yaffs_dev_t *dev, yaffs_obj_t *obj); +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev); +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj); #endif diff --git a/yaffs_attribs.c b/yaffs_attribs.c new file mode 100644 index 0000000..aaf4685 --- /dev/null +++ b/yaffs_attribs.c @@ -0,0 +1,124 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "yaffs_guts.h" +#include "yaffs_attribs.h" + +void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) +{ + obj->yst_uid = oh->yst_uid; + obj->yst_gid = oh->yst_gid; + obj->yst_atime = oh->yst_atime; + obj->yst_mtime = oh->yst_mtime; + obj->yst_ctime = oh->yst_ctime; + obj->yst_rdev = oh->yst_rdev; +} + +void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj) +{ + oh->yst_uid = obj->yst_uid; + oh->yst_gid = obj->yst_gid; + oh->yst_atime = obj->yst_atime; + oh->yst_mtime = obj->yst_mtime; + oh->yst_ctime = obj->yst_ctime; + oh->yst_rdev = obj->yst_rdev; + +} + +void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c) +{ + obj->yst_mtime = Y_CURRENT_TIME; + if (do_a) + obj->yst_atime = obj->yst_atime; + if (do_c) + obj->yst_ctime = obj->yst_atime; +} + +void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev) +{ + yaffs_load_current_time(obj, 1, 1); + obj->yst_rdev = rdev; + obj->yst_uid = uid; + obj->yst_gid = gid; +} + +loff_t yaffs_get_file_size(struct yaffs_obj *obj) +{ + YCHAR *alias = NULL; + obj = yaffs_get_equivalent_obj(obj); + + switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: + return obj->variant.file_variant.file_size; + case YAFFS_OBJECT_TYPE_SYMLINK: + alias = obj->variant.symlink_variant.alias; + if (!alias) + return 0; + return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH); + default: + return 0; + } +} + +int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = attr->ia_valid; + + if (valid & ATTR_MODE) + obj->yst_mode = attr->ia_mode; + if (valid & ATTR_UID) + obj->yst_uid = attr->ia_uid; + if (valid & ATTR_GID) + obj->yst_gid = attr->ia_gid; + + if (valid & ATTR_ATIME) + obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime); + if (valid & ATTR_CTIME) + obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime); + if (valid & ATTR_MTIME) + obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); + + if (valid & ATTR_SIZE) + yaffs_resize_file(obj, attr->ia_size); + + yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); + + return YAFFS_OK; + +} + +int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = 0; + + attr->ia_mode = obj->yst_mode; + valid |= ATTR_MODE; + attr->ia_uid = obj->yst_uid; + valid |= ATTR_UID; + attr->ia_gid = obj->yst_gid; + valid |= ATTR_GID; + + Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime; + valid |= ATTR_ATIME; + Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime; + valid |= ATTR_CTIME; + Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; + valid |= ATTR_MTIME; + + attr->ia_size = yaffs_get_file_size(obj); + valid |= ATTR_SIZE; + + attr->ia_valid = valid; + + return YAFFS_OK; +} diff --git a/yaffs_qsort.h b/yaffs_attribs.h similarity index 50% rename from yaffs_qsort.h rename to yaffs_attribs.h index 4a4981b..33d541d 100644 --- a/yaffs_qsort.h +++ b/yaffs_attribs.h @@ -13,22 +13,16 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ +#ifndef __YAFFS_ATTRIBS_H__ +#define __YAFFS_ATTRIBS_H__ -#ifndef __YAFFS_QSORT_H__ -#define __YAFFS_QSORT_H__ +#include "yaffs_guts.h" -#ifdef __KERNEL__ -#include +void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh); +void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj); +void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev); +void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c); +int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr); +int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr); -extern void yaffs_qsort(void *const base, size_t total_elems, size_t size, - int (*cmp)(const void *, const void *)){ - sort(base, total_elems, size, cmp, NULL); -} - -#else - -extern void yaffs_qsort(void *const base, size_t total_elems, size_t size, - int (*cmp)(const void *, const void *)); - -#endif #endif diff --git a/yaffs_bitmap.c b/yaffs_bitmap.c index 85c8c1d..5d1cfb2 100644 --- a/yaffs_bitmap.c +++ b/yaffs_bitmap.c @@ -17,65 +17,65 @@ * Chunk bitmap manipulations */ -static Y_INLINE __u8 *yaffs_block_bits(yaffs_dev_t *dev, int blk) +static Y_INLINE u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), - blk)); + (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), + blk)); YBUG(); } return dev->chunk_bits + - (dev->chunk_bit_stride * (blk - dev->internal_start_block)); + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); } -void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk) +void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block || - chunk < 0 || chunk >= dev->param.chunks_per_block) { + chunk < 0 || chunk >= dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR), - blk, chunk)); + (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid" TENDSTR), + blk, chunk)); YBUG(); } } -void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk) +void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk) { - __u8 *blk_bits = yaffs_block_bits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); memset(blk_bits, 0, dev->chunk_bit_stride); } -void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) +void yaffs_clear_chunk_bit(struct yaffs_dev *dev, int blk, int chunk) { - __u8 *blk_bits = yaffs_block_bits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); yaffs_verify_chunk_bit_id(dev, blk, chunk); blk_bits[chunk / 8] &= ~(1 << (chunk & 7)); } -void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) +void yaffs_set_chunk_bit(struct yaffs_dev *dev, int blk, int chunk) { - __u8 *blk_bits = yaffs_block_bits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); yaffs_verify_chunk_bit_id(dev, blk, chunk); blk_bits[chunk / 8] |= (1 << (chunk & 7)); } -int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk) +int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk) { - __u8 *blk_bits = yaffs_block_bits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); yaffs_verify_chunk_bit_id(dev, blk, chunk); return (blk_bits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0; } -int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk) +int yaffs_still_some_chunks(struct yaffs_dev *dev, int blk) { - __u8 *blk_bits = yaffs_block_bits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); int i; for (i = 0; i < dev->chunk_bit_stride; i++) { if (*blk_bits) @@ -85,13 +85,13 @@ int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk) return 0; } -int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk) +int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk) { - __u8 *blk_bits = yaffs_block_bits(dev, blk); + u8 *blk_bits = yaffs_block_bits(dev, blk); int i; int n = 0; for (i = 0; i < dev->chunk_bit_stride; i++) { - __u8 x = *blk_bits; + u8 x = *blk_bits; while (x) { if (x & 1) n++; @@ -102,4 +102,3 @@ int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk) } return n; } - diff --git a/yaffs_bitmap.h b/yaffs_bitmap.h index ea755be..cf9ea58 100644 --- a/yaffs_bitmap.h +++ b/yaffs_bitmap.h @@ -22,12 +22,12 @@ #include "yaffs_guts.h" -void yaffs_verify_chunk_bit_id(yaffs_dev_t *dev, int blk, int chunk); -void yaffs_clear_chunk_bits(yaffs_dev_t *dev, int blk); -void yaffs_clear_chunk_bit(yaffs_dev_t *dev, int blk, int chunk); -void yaffs_set_chunk_bit(yaffs_dev_t *dev, int blk, int chunk); -int yaffs_check_chunk_bit(yaffs_dev_t *dev, int blk, int chunk); -int yaffs_still_some_chunks(yaffs_dev_t *dev, int blk); -int yaffs_count_chunk_bits(yaffs_dev_t *dev, int blk); +void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk); +void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk); +void yaffs_clear_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +void yaffs_set_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +int yaffs_still_some_chunks(struct yaffs_dev *dev, int blk); +int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk); #endif diff --git a/yaffs_checkptrw.c b/yaffs_checkptrw.c index 82d6874..2cb144c 100644 --- a/yaffs_checkptrw.c +++ b/yaffs_checkptrw.c @@ -14,38 +14,41 @@ #include "yaffs_checkptrw.h" #include "yaffs_getblockinfo.h" -static int yaffs2_checkpt_space_ok(yaffs_dev_t *dev) +static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev) { int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, - (TSTR("checkpt blocks available = %d" TENDSTR), - blocks_avail)); + (TSTR("checkpt blocks available = %d" TENDSTR), blocks_avail)); return (blocks_avail <= 0) ? 0 : 1; } - -static int yaffs_checkpt_erase(yaffs_dev_t *dev) +static int yaffs_checkpt_erase(struct yaffs_dev *dev) { int i; if (!dev->param.erase_fn) return 0; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d"TENDSTR), - dev->internal_start_block, dev->internal_end_block)); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("checking blocks %d to %d" TENDSTR), + dev->internal_start_block, + dev->internal_end_block)); for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { - yaffs_block_info_t *bi = yaffs_get_block_info(dev, i); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("erasing checkpt block %d"TENDSTR), i)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("erasing checkpt block %d" TENDSTR), i)); dev->n_erasures++; - if (dev->param.erase_fn(dev, i - dev->block_offset /* realign */)) { + if (dev->param. + erase_fn(dev, + i - dev->block_offset /* realign */ )) { bi->block_state = YAFFS_BLOCK_STATE_EMPTY; dev->n_erased_blocks++; - dev->n_free_chunks += dev->param.chunks_per_block; + dev->n_free_chunks += + dev->param.chunks_per_block; } else { dev->param.bad_block_fn(dev, i); bi->block_state = YAFFS_BLOCK_STATE_DEAD; @@ -58,93 +61,103 @@ static int yaffs_checkpt_erase(yaffs_dev_t *dev) return 1; } - -static void yaffs2_checkpt_find_erased_block(yaffs_dev_t *dev) +static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev) { - int i; + int i; int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; T(YAFFS_TRACE_CHECKPOINT, - (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR), - dev->n_erased_blocks, dev->param.n_reserved_blocks, blocks_avail, dev->checkpt_next_block)); + (TSTR + ("allocating checkpt block: erased %d reserved %d avail %d next %d " + TENDSTR), dev->n_erased_blocks, dev->param.n_reserved_blocks, + blocks_avail, dev->checkpt_next_block)); if (dev->checkpt_next_block >= 0 && - dev->checkpt_next_block <= dev->internal_end_block && - blocks_avail > 0) { + dev->checkpt_next_block <= dev->internal_end_block && + blocks_avail > 0) { - for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { - yaffs_block_info_t *bi = yaffs_get_block_info(dev, i); + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; + i++) { + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, i); if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { dev->checkpt_next_block = i + 1; dev->checkpt_cur_block = i; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("allocating checkpt block %d"TENDSTR), i)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("allocating checkpt block %d" TENDSTR), + i)); return; } } } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks"TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, (TSTR("out of checkpt blocks" TENDSTR))); dev->checkpt_next_block = -1; dev->checkpt_cur_block = -1; } -static void yaffs2_checkpt_find_block(yaffs_dev_t *dev) +static void yaffs2_checkpt_find_block(struct yaffs_dev *dev) { - int i; - yaffs_ext_tags tags; + int i; + struct yaffs_ext_tags tags; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), - dev->blocks_in_checkpt, dev->checkpt_next_block)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), + dev->blocks_in_checkpt, dev->checkpt_next_block)); if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) - for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) { + for (i = dev->checkpt_next_block; i <= dev->internal_end_block; + i++) { int chunk = i * dev->param.chunks_per_block; int realigned_chunk = chunk - dev->chunk_offset; dev->param.read_chunk_tags_fn(dev, realigned_chunk, - NULL, &tags); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), - i, tags.obj_id, tags.seq_number, tags.ecc_result)); + NULL, &tags); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("find next checkpt block: search: block %d oid %d seq %d eccr %d" + TENDSTR), i, tags.obj_id, tags.seq_number, + tags.ecc_result)); if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) { /* Right kind of block */ dev->checkpt_next_block = tags.obj_id; dev->checkpt_cur_block = i; - dev->checkpt_block_list[dev->blocks_in_checkpt] = i; + dev->checkpt_block_list[dev-> + blocks_in_checkpt] = i; dev->blocks_in_checkpt++; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("found checkpt block %d"TENDSTR), i)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("found checkpt block %d" TENDSTR), i)); return; } } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("found no more checkpt blocks"TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("found no more checkpt blocks" TENDSTR))); dev->checkpt_next_block = -1; dev->checkpt_cur_block = -1; } - -int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing) +int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing) { - dev->checkpt_open_write = writing; /* Got the functions we need? */ if (!dev->param.write_chunk_tags_fn || - !dev->param.read_chunk_tags_fn || - !dev->param.erase_fn || - !dev->param.bad_block_fn) + !dev->param.read_chunk_tags_fn || + !dev->param.erase_fn || !dev->param.bad_block_fn) return 0; if (writing && !yaffs2_checkpt_space_ok(dev)) return 0; if (!dev->checkpt_buffer) - dev->checkpt_buffer = YMALLOC_DMA(dev->param.total_bytes_per_chunk); + dev->checkpt_buffer = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); if (!dev->checkpt_buffer) return 0; - dev->checkpt_page_seq = 0; dev->checkpt_byte_count = 0; dev->checkpt_sum = 0; @@ -165,9 +178,12 @@ int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing) /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully) * going to be way more than we need */ dev->blocks_in_checkpt = 0; - dev->checkpt_max_blocks = (dev->internal_end_block - dev->internal_start_block)/16 + 2; - dev->checkpt_block_list = YMALLOC(sizeof(int) * dev->checkpt_max_blocks); - if(!dev->checkpt_block_list) + dev->checkpt_max_blocks = + (dev->internal_end_block - dev->internal_start_block) / 16 + + 2; + dev->checkpt_block_list = + YMALLOC(sizeof(int) * dev->checkpt_max_blocks); + if (!dev->checkpt_block_list) return 0; for (i = 0; i < dev->checkpt_max_blocks; i++) @@ -177,20 +193,20 @@ int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing) return 1; } -int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum) +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum) { - __u32 composite_sum; - composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); + u32 composite_sum; + composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); *sum = composite_sum; return 1; } -static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev) +static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev) { int chunk; int realigned_chunk; - yaffs_ext_tags tags; + struct yaffs_ext_tags tags; if (dev->checkpt_cur_block < 0) { yaffs2_checkpt_find_erased_block(dev); @@ -201,30 +217,35 @@ static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev) return 0; tags.is_deleted = 0; - tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ + tags.obj_id = dev->checkpt_next_block; /* Hint to next place to look */ tags.chunk_id = dev->checkpt_page_seq + 1; - tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; + tags.seq_number = YAFFS_SEQUENCE_CHECKPOINT_DATA; tags.n_bytes = dev->data_bytes_per_chunk; if (dev->checkpt_cur_chunk == 0) { /* First chunk we write for the block? Set block state to checkpoint */ - yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->checkpt_cur_block); + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, dev->checkpt_cur_block); bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; dev->blocks_in_checkpt++; } - chunk = dev->checkpt_cur_block * dev->param.chunks_per_block + dev->checkpt_cur_chunk; - + chunk = + dev->checkpt_cur_block * dev->param.chunks_per_block + + dev->checkpt_cur_chunk; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), - chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, tags.chunk_id)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), + chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, tags.obj_id, + tags.chunk_id)); realigned_chunk = chunk - dev->chunk_offset; dev->n_page_writes++; dev->param.write_chunk_tags_fn(dev, realigned_chunk, - dev->checkpt_buffer, &tags); + dev->checkpt_buffer, &tags); dev->checkpt_byte_offs = 0; dev->checkpt_page_seq++; dev->checkpt_cur_chunk++; @@ -237,16 +258,12 @@ static int yaffs2_checkpt_flush_buffer(yaffs_dev_t *dev) return 1; } - -int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes) +int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes) { int i = 0; int ok = 1; - - __u8 * data_bytes = (__u8 *)data; - - + u8 *data_bytes = (u8 *) data; if (!dev->checkpt_buffer) return 0; @@ -264,26 +281,24 @@ int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes) data_bytes++; dev->checkpt_byte_count++; - if (dev->checkpt_byte_offs < 0 || - dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) ok = yaffs2_checkpt_flush_buffer(dev); } return i; } -int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes) +int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes) { int i = 0; int ok = 1; - yaffs_ext_tags tags; - + struct yaffs_ext_tags tags; int chunk; int realigned_chunk; - __u8 *data_bytes = (__u8 *)data; + u8 *data_bytes = (u8 *) data; if (!dev->checkpt_buffer) return 0; @@ -293,9 +308,8 @@ int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes) while (i < n_bytes && ok) { - if (dev->checkpt_byte_offs < 0 || - dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { if (dev->checkpt_cur_block < 0) { yaffs2_checkpt_find_block(dev); @@ -306,35 +320,39 @@ int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes) ok = 0; else { chunk = dev->checkpt_cur_block * - dev->param.chunks_per_block + - dev->checkpt_cur_chunk; + dev->param.chunks_per_block + + dev->checkpt_cur_chunk; realigned_chunk = chunk - dev->chunk_offset; - + dev->n_page_reads++; /* read in the next chunk */ dev->param.read_chunk_tags_fn(dev, - realigned_chunk, - dev->checkpt_buffer, - &tags); - - if (tags.chunk_id != (dev->checkpt_page_seq + 1) || - tags.ecc_result > YAFFS_ECC_RESULT_FIXED || - tags.seq_number != YAFFS_SEQUENCE_CHECKPOINT_DATA) + realigned_chunk, + dev-> + checkpt_buffer, + &tags); + + if (tags.chunk_id != (dev->checkpt_page_seq + 1) + || tags.ecc_result > YAFFS_ECC_RESULT_FIXED + || tags.seq_number != + YAFFS_SEQUENCE_CHECKPOINT_DATA) ok = 0; dev->checkpt_byte_offs = 0; dev->checkpt_page_seq++; dev->checkpt_cur_chunk++; - if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) + if (dev->checkpt_cur_chunk >= + dev->param.chunks_per_block) dev->checkpt_cur_block = -1; } } if (ok) { - *data_bytes = dev->checkpt_buffer[dev->checkpt_byte_offs]; + *data_bytes = + dev->checkpt_buffer[dev->checkpt_byte_offs]; dev->checkpt_sum += *data_bytes; dev->checkpt_xor ^= *data_bytes; dev->checkpt_byte_offs++; @@ -344,21 +362,24 @@ int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes) } } - return i; + return i; } -int yaffs_checkpt_close(yaffs_dev_t *dev) +int yaffs_checkpt_close(struct yaffs_dev *dev) { if (dev->checkpt_open_write) { if (dev->checkpt_byte_offs != 0) yaffs2_checkpt_flush_buffer(dev); - } else if(dev->checkpt_block_list){ + } else if (dev->checkpt_block_list) { int i; - for (i = 0; i < dev->blocks_in_checkpt && dev->checkpt_block_list[i] >= 0; i++) { + for (i = 0; + i < dev->blocks_in_checkpt + && dev->checkpt_block_list[i] >= 0; i++) { int blk = dev->checkpt_block_list[i]; - yaffs_block_info_t *bi = NULL; - if( dev->internal_start_block <= blk && blk <= dev->internal_end_block) + struct yaffs_block_info *bi = NULL; + if (dev->internal_start_block <= blk + && blk <= dev->internal_end_block) bi = yaffs_get_block_info(dev, blk); if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY) bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; @@ -370,12 +391,12 @@ int yaffs_checkpt_close(yaffs_dev_t *dev) dev->checkpt_block_list = NULL; } - dev->n_free_chunks -= dev->blocks_in_checkpt * dev->param.chunks_per_block; + dev->n_free_chunks -= + dev->blocks_in_checkpt * dev->param.chunks_per_block; dev->n_erased_blocks -= dev->blocks_in_checkpt; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint byte count %d" TENDSTR), - dev->checkpt_byte_count)); + dev->checkpt_byte_count)); if (dev->checkpt_buffer) { /* free the buffer */ @@ -386,15 +407,13 @@ int yaffs_checkpt_close(yaffs_dev_t *dev) return 0; } -int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev) +int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev) { /* Erase the checkpoint data */ - T(YAFFS_TRACE_CHECKPOINT, (TSTR("checkpoint invalidate of %d blocks"TENDSTR), - dev->blocks_in_checkpt)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("checkpoint invalidate of %d blocks" TENDSTR), + dev->blocks_in_checkpt)); return yaffs_checkpt_erase(dev); } - - - diff --git a/yaffs_checkptrw.h b/yaffs_checkptrw.h index 582b89c..361c606 100644 --- a/yaffs_checkptrw.h +++ b/yaffs_checkptrw.h @@ -18,17 +18,16 @@ #include "yaffs_guts.h" -int yaffs2_checkpt_open(yaffs_dev_t *dev, int writing); +int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing); -int yaffs2_checkpt_wr(yaffs_dev_t *dev, const void *data, int n_bytes); +int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes); -int yaffs2_checkpt_rd(yaffs_dev_t *dev, void *data, int n_bytes); +int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes); -int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum); +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum); -int yaffs_checkpt_close(yaffs_dev_t *dev); - -int yaffs2_checkpt_invalidate_stream(yaffs_dev_t *dev); +int yaffs_checkpt_close(struct yaffs_dev *dev); +int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev); #endif diff --git a/yaffs_ecc.c b/yaffs_ecc.c index 35f8747..0ea0305 100644 --- a/yaffs_ecc.c +++ b/yaffs_ecc.c @@ -106,7 +106,7 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc) b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) { /* odd number of bits in the byte */ + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; } @@ -160,11 +160,10 @@ void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc) #endif } - /* Correct the ECC on a 256 byte block of data */ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc) + const unsigned char *test_ecc) { unsigned char d0, d1, d2; /* deltas */ @@ -173,7 +172,7 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, d2 = read_ecc[2] ^ test_ecc[2]; if ((d0 | d1 | d2) == 0) - return 0; /* no error */ + return 0; /* no error */ if (((d0 ^ (d0 >> 1)) & 0x55) == 0x55 && ((d1 ^ (d1 >> 1)) & 0x55) == 0x55 && @@ -220,19 +219,18 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, data[byte] ^= (1 << bit); - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } if ((yaffs_count_bits(d0) + - yaffs_count_bits(d1) + - yaffs_count_bits(d2)) == 1) { + yaffs_count_bits(d1) + yaffs_count_bits(d2)) == 1) { /* Reccoverable error in ecc */ read_ecc[0] = test_ecc[0]; read_ecc[1] = test_ecc[1]; read_ecc[2] = test_ecc[2]; - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } /* Unrecoverable error */ @@ -241,12 +239,11 @@ int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, } - /* * ECCxxxOther does ECC calcs on arbitrary n bytes of data */ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, - yaffs_ecc_other *ecc_other) + struct yaffs_ecc_other *ecc_other) { unsigned int i; @@ -259,7 +256,7 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) { + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; @@ -273,8 +270,8 @@ void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, } int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, - yaffs_ecc_other *read_ecc, - const yaffs_ecc_other *test_ecc) + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc) { unsigned char delta_col; /* column parity delta */ unsigned delta_line; /* line parity delta */ @@ -283,10 +280,11 @@ int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, delta_col = read_ecc->col_parity ^ test_ecc->col_parity; delta_line = read_ecc->line_parity ^ test_ecc->line_parity; - delta_line_prime = read_ecc->line_parity_prime ^ test_ecc->line_parity_prime; + delta_line_prime = + read_ecc->line_parity_prime ^ test_ecc->line_parity_prime; if ((delta_col | delta_line | delta_line_prime) == 0) - return 0; /* no error */ + return 0; /* no error */ if (delta_line == ~delta_line_prime && (((delta_col ^ (delta_col >> 1)) & 0x15) == 0x15)) { @@ -306,15 +304,16 @@ int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, data[delta_line] ^= (1 << bit); - return 1; /* corrected */ + return 1; /* corrected */ } - if ((yaffs_count_bits32(delta_line) + yaffs_count_bits32(delta_line_prime) + - yaffs_count_bits(delta_col)) == 1) { + if ((yaffs_count_bits32(delta_line) + + yaffs_count_bits32(delta_line_prime) + + yaffs_count_bits(delta_col)) == 1) { /* Reccoverable error in ecc */ *read_ecc = *test_ecc; - return 1; /* corrected */ + return 1; /* corrected */ } /* Unrecoverable error */ diff --git a/yaffs_ecc.h b/yaffs_ecc.h index f505ab5..b0c461d 100644 --- a/yaffs_ecc.h +++ b/yaffs_ecc.h @@ -26,19 +26,19 @@ #ifndef __YAFFS_ECC_H__ #define __YAFFS_ECC_H__ -typedef struct { +struct yaffs_ecc_other { unsigned char col_parity; unsigned line_parity; unsigned line_parity_prime; -} yaffs_ecc_other; +}; void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc); int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc); + const unsigned char *test_ecc); void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, - yaffs_ecc_other *ecc); + struct yaffs_ecc_other *ecc); int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, - yaffs_ecc_other *read_ecc, - const yaffs_ecc_other *test_ecc); + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc); #endif diff --git a/yaffs_getblockinfo.h b/yaffs_getblockinfo.h index 1c43b6c..108c361 100644 --- a/yaffs_getblockinfo.h +++ b/yaffs_getblockinfo.h @@ -20,7 +20,8 @@ #include "yaffs_trace.h" /* Function to manipulate block info */ -static Y_INLINE yaffs_block_info_t *yaffs_get_block_info(yaffs_dev_t * dev, int blk) +static Y_INLINE struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev + *dev, int blk) { if (blk < dev->internal_start_block || blk > dev->internal_end_block) { T(YAFFS_TRACE_ERROR, diff --git a/yaffs_guts.c b/yaffs_guts.c index eea828a..a9fc46c 100644 --- a/yaffs_guts.c +++ b/yaffs_guts.c @@ -33,87 +33,84 @@ #include "yaffs_nameval.h" #include "yaffs_allocator.h" +#include "yaffs_attribs.h" + /* Note YAFFS_GC_GOOD_ENOUGH must be <= YAFFS_GC_PASSIVE_THRESHOLD */ #define YAFFS_GC_GOOD_ENOUGH 2 #define YAFFS_GC_PASSIVE_THRESHOLD 4 #include "yaffs_ecc.h" - - /* Robustification (if it ever comes about...) */ -static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block); -static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk, - int erased_ok); -static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_ext_tags *tags); -static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, - const yaffs_ext_tags *tags); +static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block); +static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, + int erased_ok); +static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags); +static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk, + const struct yaffs_ext_tags *tags); /* Other local prototypes */ -static void yaffs_update_parent(yaffs_obj_t *obj); -static int yaffs_unlink_obj(yaffs_obj_t *obj); -static int yaffs_obj_cache_dirty(yaffs_obj_t *obj); - -static int yaffs_write_new_chunk(yaffs_dev_t *dev, - const __u8 *buffer, - yaffs_ext_tags *tags, - int use_reserver); - +static void yaffs_update_parent(struct yaffs_obj *obj); +static int yaffs_unlink_obj(struct yaffs_obj *obj); +static int yaffs_obj_cache_dirty(struct yaffs_obj *obj); -static yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, - yaffs_obj_type type); +static int yaffs_write_new_chunk(struct yaffs_dev *dev, + const u8 * buffer, + struct yaffs_ext_tags *tags, int use_reserver); +static struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, + enum yaffs_obj_type type); -static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod); +static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, + struct yaffs_xattr_mod *xmod); -static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj); -static int yaffs_check_structures(void); -static int yaffs_generic_obj_del(yaffs_obj_t *in); +static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj); +static int yaffs_generic_obj_del(struct yaffs_obj *in); -static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, - int nand_chunk); +static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk); -static int yaffs_unlink_worker(yaffs_obj_t *obj); +static int yaffs_unlink_worker(struct yaffs_obj *obj); -static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id, - int chunk_obj); +static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, + int chunk_obj); -static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver, - yaffs_block_info_t **block_ptr); +static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, + struct yaffs_block_info **block_ptr); -static void yaffs_check_obj_details_loaded(yaffs_obj_t *in); +static void yaffs_check_obj_details_loaded(struct yaffs_obj *in); -static void yaffs_invalidate_whole_cache(yaffs_obj_t *in); -static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id); +static void yaffs_invalidate_whole_cache(struct yaffs_obj *in); +static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, + int chunk_id); -static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk, - yaffs_ext_tags *tags); +static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags); -static int yaffs_verify_chunk_written(yaffs_dev_t *dev, - int nand_chunk, - const __u8 *data, - yaffs_ext_tags *tags); - - -static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *oh_name, int buff_size); -static void yaffs_load_oh_from_name(yaffs_dev_t *dev,YCHAR *oh_name, const YCHAR *name); +static int yaffs_verify_chunk_written(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, + struct yaffs_ext_tags *tags); +static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name, + const YCHAR * oh_name, int buff_size); +static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, + const YCHAR * name); /* Function to calculate chunk and offset */ -static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunk_out, - __u32 *offset_out) +static void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, + int *chunk_out, u32 * offset_out) { int chunk; - __u32 offset; + u32 offset; - chunk = (__u32)(addr >> dev->chunk_shift); + chunk = (u32) (addr >> dev->chunk_shift); if (dev->chunk_div == 1) { /* easy power of 2 case */ - offset = (__u32)(addr & dev->chunk_mask); + offset = (u32) (addr & dev->chunk_mask); } else { /* Non power-of-2 case */ @@ -121,8 +118,8 @@ static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunk_out, chunk /= dev->chunk_div; - chunk_base = ((loff_t)chunk) * dev->data_bytes_per_chunk; - offset = (__u32)(addr - chunk_base); + chunk_base = ((loff_t) chunk) * dev->data_bytes_per_chunk; + offset = (u32) (addr - chunk_base); } *chunk_out = chunk; @@ -135,7 +132,7 @@ static void yaffs_addr_to_chunk(yaffs_dev_t *dev, loff_t addr, int *chunk_out, * be hellishly efficient. */ -static __u32 calc_shifts_ceiling(__u32 x) +static u32 calc_shifts_ceiling(u32 x) { int extra_bits; int shifts; @@ -158,16 +155,16 @@ static __u32 calc_shifts_ceiling(__u32 x) /* Function to return the number of shifts to get a 1 in bit 0 */ -static __u32 calc_shifts(__u32 x) +static u32 calc_shifts(u32 x) { - __u32 shifts; + u32 shifts; - shifts = 0; + shifts = 0; if (!x) return 0; - while (!(x&1)) { + while (!(x & 1)) { x >>= 1; shifts++; } @@ -175,16 +172,14 @@ static __u32 calc_shifts(__u32 x) return shifts; } - - /* * Temporary buffer manipulations. */ -static int yaffs_init_tmp_buffers(yaffs_dev_t *dev) +static int yaffs_init_tmp_buffers(struct yaffs_dev *dev) { int i; - __u8 *buf = (__u8 *)1; + u8 *buf = (u8 *) 1; memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer)); @@ -197,7 +192,7 @@ static int yaffs_init_tmp_buffers(yaffs_dev_t *dev) return buf ? YAFFS_OK : YAFFS_FAIL; } -__u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no) +u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev, int line_no) { int i, j; @@ -223,7 +218,8 @@ __u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no) (TSTR("Out of temp buffers at line %d, other held by lines:"), line_no)); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) - T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->temp_buffer[i].line)); + T(YAFFS_TRACE_BUFFERS, + (TSTR(" %d "), dev->temp_buffer[i].line)); T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR))); @@ -237,8 +233,7 @@ __u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no) } -void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer, - int line_no) +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no) { int i; @@ -265,7 +260,7 @@ void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer, /* * Determine if we have a managed buffer. */ -int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const __u8 *buffer) +int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 * buffer) { int i; @@ -283,7 +278,7 @@ int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const __u8 *buffer) return 1; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR))); + (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR))); return 0; } @@ -291,9 +286,6 @@ int yaffs_is_managed_tmp_buffer(yaffs_dev_t *dev, const __u8 *buffer) * Verification code */ - - - /* * Simple hash function. Needs to have a reasonable spread */ @@ -309,22 +301,21 @@ static Y_INLINE int yaffs_hash_fn(int n) * Note that root might have a presence in NAND if permissions are set. */ -yaffs_obj_t *yaffs_root(yaffs_dev_t *dev) +struct yaffs_obj *yaffs_root(struct yaffs_dev *dev) { return dev->root_dir; } -yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev) +struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev) { return dev->lost_n_found; } - /* * Erased NAND checking functions */ -int yaffs_check_ff(__u8 *buffer, int n_bytes) +int yaffs_check_ff(u8 * buffer, int n_bytes) { /* Horrible, slow implementation */ while (n_bytes--) { @@ -335,12 +326,11 @@ int yaffs_check_ff(__u8 *buffer, int n_bytes) return 1; } -static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, - int nand_chunk) +static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk) { int retval = YAFFS_OK; - __u8 *data = yaffs_get_temp_buffer(dev, __LINE__); - yaffs_ext_tags tags; + u8 *data = yaffs_get_temp_buffer(dev, __LINE__); + struct yaffs_ext_tags tags; int result; result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags); @@ -360,22 +350,21 @@ static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, } - -static int yaffs_verify_chunk_written(yaffs_dev_t *dev, - int nand_chunk, - const __u8 *data, - yaffs_ext_tags *tags) +static int yaffs_verify_chunk_written(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, + struct yaffs_ext_tags *tags) { int retval = YAFFS_OK; - yaffs_ext_tags temp_tags; - __u8 *buffer = yaffs_get_temp_buffer(dev,__LINE__); + struct yaffs_ext_tags temp_tags; + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); int result; - - result = yaffs_rd_chunk_tags_nand(dev,nand_chunk,buffer,&temp_tags); - if(memcmp(buffer,data,dev->data_bytes_per_chunk) || - temp_tags.obj_id != tags->obj_id || - temp_tags.chunk_id != tags->chunk_id || - temp_tags.n_bytes != tags->n_bytes) + + result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, buffer, &temp_tags); + if (memcmp(buffer, data, dev->data_bytes_per_chunk) || + temp_tags.obj_id != tags->obj_id || + temp_tags.chunk_id != tags->chunk_id || + temp_tags.n_bytes != tags->n_bytes) retval = YAFFS_FAIL; yaffs_release_temp_buffer(dev, buffer, __LINE__); @@ -383,10 +372,9 @@ static int yaffs_verify_chunk_written(yaffs_dev_t *dev, return retval; } -static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, - const __u8 *data, - yaffs_ext_tags *tags, - int use_reserver) +static int yaffs_write_new_chunk(struct yaffs_dev *dev, + const u8 * data, + struct yaffs_ext_tags *tags, int use_reserver) { int attempts = 0; int write_ok = 0; @@ -395,7 +383,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, yaffs2_checkpt_invalidate(dev); do { - yaffs_block_info_t *bi = 0; + struct yaffs_block_info *bi = 0; int erased_ok = 0; chunk = yaffs_alloc_chunk(dev, use_reserver, &bi); @@ -410,7 +398,7 @@ static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, * * Check the first page we try to write in a block. * If the check passes then we don't need to check any - * more. If the check fails, we check again... + * more. If the check fails, we check again... * If the block has been erased, we don't need to check. * * However, if the block has been prioritised for gc, @@ -431,30 +419,30 @@ static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, /* let's give it a try */ attempts++; - if(dev->param.always_check_erased) + if (dev->param.always_check_erased) bi->skip_erased_check = 0; if (!bi->skip_erased_check) { erased_ok = yaffs_check_chunk_erased(dev, chunk); if (erased_ok != YAFFS_OK) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs chunk %d was not erased" - TENDSTR), chunk)); + (TSTR("**>> yaffs chunk %d was not erased" + TENDSTR), chunk)); /* If not erased, delete this one, * skip rest of block and * try another chunk */ - yaffs_chunk_del(dev,chunk,1,__LINE__); - yaffs_skip_rest_of_block(dev); + yaffs_chunk_del(dev, chunk, 1, __LINE__); + yaffs_skip_rest_of_block(dev); continue; } } - write_ok = yaffs_wr_chunk_tags_nand(dev, chunk, - data, tags); + write_ok = yaffs_wr_chunk_tags_nand(dev, chunk, data, tags); - if(!bi->skip_erased_check) - write_ok = yaffs_verify_chunk_written(dev, chunk, data, tags); + if (!bi->skip_erased_check) + write_ok = + yaffs_verify_chunk_written(dev, chunk, data, tags); if (write_ok != YAFFS_OK) { /* Clean up aborted write, skip to next block and @@ -469,15 +457,15 @@ static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, yaffs_handle_chunk_wr_ok(dev, chunk, data, tags); } while (write_ok != YAFFS_OK && - (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); + (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); if (!write_ok) chunk = -1; if (attempts > 1) { T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs write required %d attempts" TENDSTR), - attempts)); + (TSTR("**>> yaffs write required %d attempts" TENDSTR), + attempts)); dev->n_retired_writes += (attempts - 1); } @@ -485,39 +473,43 @@ static int yaffs_write_new_chunk(struct yaffs_dev_s *dev, return chunk; } - - /* * Block retiring for handling a broken block. */ -static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block) +static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block) { - yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); yaffs2_checkpt_invalidate(dev); - - yaffs2_clear_oldest_dirty_seq(dev,bi); + + yaffs2_clear_oldest_dirty_seq(dev, bi); if (yaffs_mark_bad(dev, flash_block) != YAFFS_OK) { if (yaffs_erase_block(dev, flash_block) != YAFFS_OK) { - T(YAFFS_TRACE_ALWAYS, (TSTR( - "yaffs: Failed to mark bad and erase block %d" - TENDSTR), flash_block)); + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("yaffs: Failed to mark bad and erase block %d" + TENDSTR), flash_block)); } else { - yaffs_ext_tags tags; - int chunk_id = flash_block * dev->param.chunks_per_block; + struct yaffs_ext_tags tags; + int chunk_id = + flash_block * dev->param.chunks_per_block; - __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); memset(buffer, 0xff, dev->data_bytes_per_chunk); yaffs_init_tags(&tags); tags.seq_number = YAFFS_SEQUENCE_BAD_BLOCK; if (dev->param.write_chunk_tags_fn(dev, chunk_id - - dev->chunk_offset, buffer, &tags) != YAFFS_OK) - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Failed to " - TCONT("write bad block marker to block %d") - TENDSTR), flash_block)); + dev->chunk_offset, + buffer, + &tags) != YAFFS_OK) + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("yaffs: Failed to " + TCONT("write bad block marker to block %d") + TENDSTR), flash_block)); yaffs_release_temp_buffer(dev, buffer, __LINE__); } @@ -535,25 +527,26 @@ static void yaffs_retire_block(yaffs_dev_t *dev, int flash_block) * */ -static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_ext_tags *tags) +static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags) { - dev=dev; - nand_chunk=nand_chunk; - data=data; - tags=tags; + dev = dev; + nand_chunk = nand_chunk; + data = data; + tags = tags; } -static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, - const yaffs_ext_tags *tags) +static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk, + const struct yaffs_ext_tags *tags) { - dev=dev; - nand_chunk=nand_chunk; - tags=tags; + dev = dev; + nand_chunk = nand_chunk; + tags = tags; } -void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi) +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi) { if (!bi->gc_prioritise) { bi->gc_prioritise = 1; @@ -561,18 +554,19 @@ void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi) bi->chunk_error_strikes++; if (bi->chunk_error_strikes > 3) { - bi->needs_retiring = 1; /* Too many stikes, so retire this */ - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR))); + bi->needs_retiring = 1; /* Too many stikes, so retire this */ + T(YAFFS_TRACE_ALWAYS, + (TSTR("yaffs: Block struck out" TENDSTR))); } } } -static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk, - int erased_ok) +static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, + int erased_ok) { int flash_block = nand_chunk / dev->param.chunks_per_block; - yaffs_block_info_t *bi = yaffs_get_block_info(dev, flash_block); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); yaffs_handle_chunk_error(dev, bi); @@ -588,23 +582,19 @@ static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk, yaffs_skip_rest_of_block(dev); } - /*---------------- Name handling functions ------------*/ -static __u16 yaffs_calc_name_sum(const YCHAR *name) +static u16 yaffs_calc_name_sum(const YCHAR * name) { - __u16 sum = 0; - __u16 i = 1; + u16 sum = 0; + u16 i = 1; - const YUCHAR *bname = (const YUCHAR *) name; + const YUCHAR *bname = (const YUCHAR *)name; if (bname) { - while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) { + while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH / 2))) { -#ifdef CONFIG_YAFFS_CASE_INSENSITIVE - sum += yaffs_toupper(*bname) * i; -#else - sum += (*bname) * i; -#endif + /* 0x1f mask is case insensitive */ + sum += ((*bname) & 0x1f) * i; i++; bname++; } @@ -612,11 +602,15 @@ static __u16 yaffs_calc_name_sum(const YCHAR *name) return sum; } -void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name) +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name) { #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - memset(obj->short_name, 0, sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH+1)); - if (name && yaffs_strnlen(name,YAFFS_SHORT_NAME_LENGTH+1) <= YAFFS_SHORT_NAME_LENGTH) + memset(obj->short_name, 0, + sizeof(YCHAR) * (YAFFS_SHORT_NAME_LENGTH + 1)); + if (name + && yaffs_strnlen(name, + YAFFS_SHORT_NAME_LENGTH + 1) <= + YAFFS_SHORT_NAME_LENGTH) yaffs_strcpy(obj->short_name, name); else obj->short_name[0] = _Y('\0'); @@ -624,15 +618,17 @@ void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name) obj->sum = yaffs_calc_name_sum(name); } -void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh) +void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, + const struct yaffs_obj_hdr *oh) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH+1]; - memset(tmp_name,0,sizeof(tmp_name)); - yaffs_load_name_from_oh(obj->my_dev,tmp_name,oh->name,YAFFS_MAX_NAME_LENGTH+1); - yaffs_set_obj_name(obj,tmp_name); + YCHAR tmp_name[YAFFS_MAX_NAME_LENGTH + 1]; + memset(tmp_name, 0, sizeof(tmp_name)); + yaffs_load_name_from_oh(obj->my_dev, tmp_name, oh->name, + YAFFS_MAX_NAME_LENGTH + 1); + yaffs_set_obj_name(obj, tmp_name); #else - yaffs_set_obj_name(obj,oh->name); + yaffs_set_obj_name(obj, oh->name); #endif } @@ -643,44 +639,42 @@ void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh) * in the tnode. */ - -yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev) +struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev) { - yaffs_tnode_t *tn = yaffs_alloc_raw_tnode(dev); - if (tn){ + struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev); + if (tn) { memset(tn, 0, dev->tnode_size); dev->n_tnodes++; } - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ return tn; } /* FreeTnode frees up a tnode and puts it back on the free list */ -static void yaffs_free_tnode(yaffs_dev_t *dev, yaffs_tnode_t *tn) +static void yaffs_free_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { - yaffs_free_raw_tnode(dev,tn); + yaffs_free_raw_tnode(dev, tn); dev->n_tnodes--; - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ } -static void yaffs_deinit_tnodes_and_objs(yaffs_dev_t *dev) +static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev) { yaffs_deinit_raw_tnodes_and_objs(dev); dev->n_obj = 0; dev->n_tnodes = 0; } - -void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos, - unsigned val) +void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos, unsigned val) { - __u32 *map = (__u32 *)tn; - __u32 bit_in_map; - __u32 bit_in_word; - __u32 word_in_map; - __u32 mask; + u32 *map = (u32 *) tn; + u32 bit_in_map; + u32 bit_in_word; + u32 word_in_map; + u32 mask; pos &= YAFFS_TNODES_LEVEL0_MASK; val >>= dev->chunk_grp_bits; @@ -697,20 +691,21 @@ void yaffs_load_tnode_0(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos, if (dev->tnode_width > (32 - bit_in_word)) { bit_in_word = (32 - bit_in_word); word_in_map++;; - mask = dev->tnode_mask >> (/*dev->tnode_width -*/ bit_in_word); + mask = + dev->tnode_mask >> ( /*dev->tnode_width - */ bit_in_word); map[word_in_map] &= ~mask; map[word_in_map] |= (mask & (val >> bit_in_word)); } } -__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, - unsigned pos) +u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos) { - __u32 *map = (__u32 *)tn; - __u32 bit_in_map; - __u32 bit_in_word; - __u32 word_in_map; - __u32 val; + u32 *map = (u32 *) tn; + u32 bit_in_map; + u32 bit_in_word; + u32 word_in_map; + u32 val; pos &= YAFFS_TNODES_LEVEL0_MASK; @@ -720,7 +715,7 @@ __u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, val = map[word_in_map] >> bit_in_word; - if (dev->tnode_width > (32 - bit_in_word)) { + if (dev->tnode_width > (32 - bit_in_word)) { bit_in_word = (32 - bit_in_word); word_in_map++;; val |= (map[word_in_map] << bit_in_word); @@ -740,16 +735,16 @@ __u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, */ /* FindLevel0Tnode finds the level 0 tnode, if one exists. */ -yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, - yaffs_file_s *file_struct, - __u32 chunk_id) +struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id) { - yaffs_tnode_t *tn = file_struct->top; - __u32 i; + struct yaffs_tnode *tn = file_struct->top; + u32 i; int required_depth; int level = file_struct->top_level; - dev=dev; + dev = dev; /* Check sane level and chunk Id */ if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) @@ -768,15 +763,15 @@ yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, } if (required_depth > file_struct->top_level) - return NULL; /* Not tall enough, so we can't find it */ + return NULL; /* Not tall enough, so we can't find it */ /* Traverse down to level 0 */ while (level > 0 && tn) { tn = tn->internal[(chunk_id >> - (YAFFS_TNODES_LEVEL0_BITS + - (level - 1) * - YAFFS_TNODES_INTERNAL_BITS)) & - YAFFS_TNODES_INTERNAL_MASK]; + (YAFFS_TNODES_LEVEL0_BITS + + (level - 1) * + YAFFS_TNODES_INTERNAL_BITS)) & + YAFFS_TNODES_INTERNAL_MASK]; level--; } @@ -794,21 +789,21 @@ yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, * be plugged into the ttree. */ -yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, - yaffs_file_s *file_struct, - __u32 chunk_id, - yaffs_tnode_t *passed_tn) +struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn) { int required_depth; int i; int l; - yaffs_tnode_t *tn; - - __u32 x; + struct yaffs_tnode *tn; + u32 x; /* Check sane level and page Id */ - if (file_struct->top_level < 0 || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) + if (file_struct->top_level < 0 + || file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) return NULL; if (chunk_id > YAFFS_MAX_CHUNK_ID) @@ -823,7 +818,6 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, required_depth++; } - if (required_depth > file_struct->top_level) { /* Not tall enough, gotta make the tree taller */ for (i = file_struct->top_level; i < required_depth; i++) { @@ -836,7 +830,7 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, file_struct->top_level++; } else { T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: no more tnodes" TENDSTR))); + (TSTR("yaffs: no more tnodes" TENDSTR))); return NULL; } } @@ -854,24 +848,25 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & YAFFS_TNODES_INTERNAL_MASK; - if ((l > 1) && !tn->internal[x]) { /* Add missing non-level-zero tnode */ tn->internal[x] = yaffs_get_tnode(dev); - if(!tn->internal[x]) + if (!tn->internal[x]) return NULL; } else if (l == 1) { /* Looking from level 1 at level 0 */ if (passed_tn) { - /* If we already have one, then release it.*/ + /* If we already have one, then release it. */ if (tn->internal[x]) - yaffs_free_tnode(dev, tn->internal[x]); + yaffs_free_tnode(dev, + tn-> + internal[x]); tn->internal[x] = passed_tn; } else if (!tn->internal[x]) { /* Don't have one, none passed in */ tn->internal[x] = yaffs_get_tnode(dev); - if(!tn->internal[x]) + if (!tn->internal[x]) return NULL; } } @@ -882,7 +877,8 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, } else { /* top is level 0 */ if (passed_tn) { - memcpy(tn, passed_tn, (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8); + memcpy(tn, passed_tn, + (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8); yaffs_free_tnode(dev, passed_tn); } } @@ -890,21 +886,22 @@ yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, return tn; } -static int yaffs_find_chunk_in_group(yaffs_dev_t *dev, int the_chunk, - yaffs_ext_tags *tags, int obj_id, - int inode_chunk) +static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk, + struct yaffs_ext_tags *tags, int obj_id, + int inode_chunk) { int j; for (j = 0; the_chunk && j < dev->chunk_grp_size; j++) { - if (yaffs_check_chunk_bit(dev, the_chunk / dev->param.chunks_per_block, - the_chunk % dev->param.chunks_per_block)) { - - if(dev->chunk_grp_size == 1) + if (yaffs_check_chunk_bit + (dev, the_chunk / dev->param.chunks_per_block, + the_chunk % dev->param.chunks_per_block)) { + + if (dev->chunk_grp_size == 1) return the_chunk; else { yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, - tags); + tags); if (yaffs_tags_match(tags, obj_id, inode_chunk)) { /* found it; */ return the_chunk; @@ -916,111 +913,14 @@ static int yaffs_find_chunk_in_group(yaffs_dev_t *dev, int the_chunk, return -1; } -#if 0 -/* Experimental code not being used yet. Might speed up file deletion */ -/* DeleteWorker scans backwards through the tnode tree and deletes all the - * chunks and tnodes in the file. - * Returns 1 if the tree was deleted. - * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete. - */ - -static int yaffs_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, __u32 level, - int chunk_offset, int *limit) +static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk) { - int i; - int inode_chunk; - int the_chunk; - yaffs_ext_tags tags; - int found_chunk; - yaffs_dev_t *dev = in->my_dev; - - int all_done = 1; - - if (tn) { - if (level > 0) { - for (i = YAFFS_NTNODES_INTERNAL - 1; all_done && i >= 0; - i--) { - if (tn->internal[i]) { - if (limit && (*limit) < 0) { - all_done = 0; - } else { - all_done = - yaffs_del_worker(in, - tn-> - internal - [i], - level - - 1, - (chunk_offset - << - YAFFS_TNODES_INTERNAL_BITS) - + i, - limit); - } - if (all_done) { - yaffs_free_tnode(dev, - tn-> - internal[i]); - tn->internal[i] = NULL; - } - } - } - return (all_done) ? 1 : 0; - } else if (level == 0) { - int hit_limit = 0; - - for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hit_limit; - i--) { - the_chunk = yaffs_get_group_base(dev, tn, i); - if (the_chunk) { - - inode_chunk = (chunk_offset << - YAFFS_TNODES_LEVEL0_BITS) + i; - - found_chunk = - yaffs_find_chunk_in_group(dev, - the_chunk, - &tags, - in->obj_id, - inode_chunk); - - if (found_chunk > 0) { - yaffs_chunk_del(dev, - found_chunk, 1, - __LINE__); - in->n_data_chunks--; - if (limit) { - *limit = *limit - 1; - if (*limit <= 0) - hit_limit = 1; - } - - } - - yaffs_load_tnode_0(dev, tn, i, 0); - } - - } - return (i < 0) ? 1 : 0; - - } - - } - - return 1; - -} - -#endif - -static void yaffs_soft_del_chunk(yaffs_dev_t *dev, int chunk) -{ - yaffs_block_info_t *the_block; + struct yaffs_block_info *the_block; unsigned block_no; T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); - block_no = chunk / dev->param.chunks_per_block; + block_no = chunk / dev->param.chunks_per_block; the_block = yaffs_get_block_info(dev, block_no); if (the_block) { the_block->soft_del_pages++; @@ -1035,13 +935,13 @@ static void yaffs_soft_del_chunk(yaffs_dev_t *dev, int chunk) * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted. */ -static int yaffs_soft_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, - __u32 level, int chunk_offset) +static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, + u32 level, int chunk_offset) { int i; int the_chunk; int all_done = 1; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; if (tn) { if (level > 0) { @@ -1051,17 +951,17 @@ static int yaffs_soft_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, if (tn->internal[i]) { all_done = yaffs_soft_del_worker(in, - tn-> - internal[i], - level - 1, - (chunk_offset - << - YAFFS_TNODES_INTERNAL_BITS) - + i); + tn->internal + [i], + level - 1, + (chunk_offset + << + YAFFS_TNODES_INTERNAL_BITS) + + i); if (all_done) { yaffs_free_tnode(dev, - tn-> - internal[i]); + tn->internal + [i]); tn->internal[i] = NULL; } else { /* Hoosterman... how could this happen? */ @@ -1093,14 +993,14 @@ static int yaffs_soft_del_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, } -static void yaffs_soft_del_file(yaffs_obj_t *obj) +static void yaffs_soft_del_file(struct yaffs_obj *obj) { if (obj->deleted && obj->variant_type == YAFFS_OBJECT_TYPE_FILE && !obj->soft_del) { if (obj->n_data_chunks <= 0) { /* Empty file with no duplicate object headers, just delete it immediately */ yaffs_free_tnode(obj->my_dev, - obj->variant.file_variant.top); + obj->variant.file_variant.top); obj->variant.file_variant.top = NULL; T(YAFFS_TRACE_TRACING, (TSTR("yaffs: Deleting empty file %d" TENDSTR), @@ -1108,9 +1008,9 @@ static void yaffs_soft_del_file(yaffs_obj_t *obj) yaffs_generic_obj_del(obj); } else { yaffs_soft_del_worker(obj, - obj->variant.file_variant.top, - obj->variant.file_variant. - top_level, 0); + obj->variant.file_variant.top, + obj->variant. + file_variant.top_level, 0); obj->soft_del = 1; } } @@ -1131,8 +1031,9 @@ static void yaffs_soft_del_file(yaffs_obj_t *obj) * If there is no data in a subtree then it is pruned. */ -static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn, - __u32 level, int del0) +static struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, + struct yaffs_tnode *tn, u32 level, + int del0) { int i; int has_data; @@ -1140,27 +1041,29 @@ static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn, if (tn) { has_data = 0; - if(level > 0){ + if (level > 0) { for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) { if (tn->internal[i]) { tn->internal[i] = - yaffs_prune_worker(dev, tn->internal[i], - level - 1, - (i == 0) ? del0 : 1); + yaffs_prune_worker(dev, + tn->internal[i], + level - 1, + (i == + 0) ? del0 : 1); } if (tn->internal[i]) has_data++; } } else { - int tnode_size_u32 = dev->tnode_size/sizeof(__u32); - __u32 *map = (__u32 *)tn; + int tnode_size_u32 = dev->tnode_size / sizeof(u32); + u32 *map = (u32 *) tn; - for(i = 0; !has_data && i < tnode_size_u32; i++){ - if(map[i]) - has_data++; - } - } + for (i = 0; !has_data && i < tnode_size_u32; i++) { + if (map[i]) + has_data++; + } + } if (has_data == 0 && del0) { /* Free and return NULL */ @@ -1175,17 +1078,18 @@ static yaffs_tnode_t *yaffs_prune_worker(yaffs_dev_t *dev, yaffs_tnode_t *tn, } -static int yaffs_prune_tree(yaffs_dev_t *dev, - yaffs_file_s *file_struct) +static int yaffs_prune_tree(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct) { int i; int has_data; int done = 0; - yaffs_tnode_t *tn; + struct yaffs_tnode *tn; if (file_struct->top_level > 0) { file_struct->top = - yaffs_prune_worker(dev, file_struct->top, file_struct->top_level, 0); + yaffs_prune_worker(dev, file_struct->top, + file_struct->top_level, 0); /* Now we have a tree with all the non-zero branches NULL but the height * is the same as it was. @@ -1218,32 +1122,31 @@ static int yaffs_prune_tree(yaffs_dev_t *dev, /*-------------------- End of File Structure functions.-------------------*/ - /* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ -static yaffs_obj_t *yaffs_alloc_empty_obj(yaffs_dev_t *dev) +static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev) { - yaffs_obj_t *obj = yaffs_alloc_raw_obj(dev); + struct yaffs_obj *obj = yaffs_alloc_raw_obj(dev); if (obj) { dev->n_obj++; /* Now sweeten it up... */ - memset(obj, 0, sizeof(yaffs_obj_t)); + memset(obj, 0, sizeof(struct yaffs_obj)); obj->being_created = 1; obj->my_dev = dev; obj->hdr_chunk = 0; obj->variant_type = YAFFS_OBJECT_TYPE_UNKNOWN; - YINIT_LIST_HEAD(&(obj->hard_links)); - YINIT_LIST_HEAD(&(obj->hash_link)); - YINIT_LIST_HEAD(&obj->siblings); - + INIT_LIST_HEAD(&(obj->hard_links)); + INIT_LIST_HEAD(&(obj->hash_link)); + INIT_LIST_HEAD(&obj->siblings); /* Now make the directory sane */ if (dev->root_dir) { obj->parent = dev->root_dir; - ylist_add(&(obj->siblings), &dev->root_dir->variant.dir_variant.children); + list_add(&(obj->siblings), + &dev->root_dir->variant.dir_variant.children); } /* Add it to the lost and found directory. @@ -1256,19 +1159,19 @@ static yaffs_obj_t *yaffs_alloc_empty_obj(yaffs_dev_t *dev) obj->being_created = 0; } - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ return obj; } -static yaffs_obj_t *yaffs_create_fake_dir(yaffs_dev_t *dev, int number, - __u32 mode) +static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, + int number, u32 mode) { - yaffs_obj_t *obj = + struct yaffs_obj *obj = yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); if (obj) { - obj->fake = 1; /* it is fake so it might have no NAND presence... */ + obj->fake = 1; /* it is fake so it might have no NAND presence... */ obj->rename_allowed = 0; /* ... and we're not allowed to rename it... */ obj->unlink_allowed = 0; /* ... or unlink it */ obj->deleted = 0; @@ -1282,34 +1185,34 @@ static yaffs_obj_t *yaffs_create_fake_dir(yaffs_dev_t *dev, int number, } -static void yaffs_unhash_obj(yaffs_obj_t *obj) +static void yaffs_unhash_obj(struct yaffs_obj *obj) { int bucket; - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; /* If it is still linked into the bucket list, free from the list */ - if (!ylist_empty(&obj->hash_link)) { - ylist_del_init(&obj->hash_link); + if (!list_empty(&obj->hash_link)) { + list_del_init(&obj->hash_link); bucket = yaffs_hash_fn(obj->obj_id); dev->obj_bucket[bucket].count--; } } /* FreeObject frees up a Object and puts it back on the free list */ -static void yaffs_free_obj(yaffs_obj_t *obj) +static void yaffs_free_obj(struct yaffs_obj *obj) { - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; - T(YAFFS_TRACE_OS, (TSTR("FreeObject %p inode %p"TENDSTR), obj, obj->my_inode)); + T(YAFFS_TRACE_OS, + (TSTR("FreeObject %p inode %p" TENDSTR), obj, obj->my_inode)); if (!obj) YBUG(); if (obj->parent) YBUG(); - if (!ylist_empty(&obj->siblings)) + if (!list_empty(&obj->siblings)) YBUG(); - if (obj->my_inode) { /* We're still hooked up to a cached inode. * Don't delete now, but mark for later deletion @@ -1320,19 +1223,18 @@ static void yaffs_free_obj(yaffs_obj_t *obj) yaffs_unhash_obj(obj); - yaffs_free_raw_obj(dev,obj); + yaffs_free_raw_obj(dev, obj); dev->n_obj--; - dev->checkpoint_blocks_required = 0; /* force recalculation*/ + dev->checkpoint_blocks_required = 0; /* force recalculation */ } - -void yaffs_handle_defered_free(yaffs_obj_t *obj) +void yaffs_handle_defered_free(struct yaffs_obj *obj) { if (obj->defered_free) yaffs_free_obj(obj); } -static void yaffs_init_tnodes_and_objs(yaffs_dev_t *dev) +static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev) { int i; @@ -1342,18 +1244,17 @@ static void yaffs_init_tnodes_and_objs(yaffs_dev_t *dev) yaffs_init_raw_tnodes_and_objs(dev); for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - YINIT_LIST_HEAD(&dev->obj_bucket[i].list); + INIT_LIST_HEAD(&dev->obj_bucket[i].list); dev->obj_bucket[i].count = 0; } } -static int yaffs_find_nice_bucket(yaffs_dev_t *dev) +static int yaffs_find_nice_bucket(struct yaffs_dev *dev) { int i; int l = 999; int lowest = 999999; - /* Search for the shortest list or one that * isn't too long. */ @@ -1371,7 +1272,7 @@ static int yaffs_find_nice_bucket(yaffs_dev_t *dev) return l; } -static int yaffs_new_obj_id(yaffs_dev_t *dev) +static int yaffs_new_obj_id(struct yaffs_dev *dev) { int bucket = yaffs_find_nice_bucket(dev); @@ -1380,9 +1281,9 @@ static int yaffs_new_obj_id(yaffs_dev_t *dev) */ int found = 0; - struct ylist_head *i; + struct list_head *i; - __u32 n = (__u32) bucket; + u32 n = (u32) bucket; /* yaffs_check_obj_hash_sane(); */ @@ -1390,10 +1291,10 @@ static int yaffs_new_obj_id(yaffs_dev_t *dev) found = 1; n += YAFFS_NOBJECT_BUCKETS; if (1 || dev->obj_bucket[bucket].count > 0) { - ylist_for_each(i, &dev->obj_bucket[bucket].list) { + list_for_each(i, &dev->obj_bucket[bucket].list) { /* If there is already one in the list */ - if (i && ylist_entry(i, yaffs_obj_t, - hash_link)->obj_id == n) { + if (i && list_entry(i, struct yaffs_obj, + hash_link)->obj_id == n) { found = 0; } } @@ -1403,25 +1304,25 @@ static int yaffs_new_obj_id(yaffs_dev_t *dev) return n; } -static void yaffs_hash_obj(yaffs_obj_t *in) +static void yaffs_hash_obj(struct yaffs_obj *in) { int bucket = yaffs_hash_fn(in->obj_id); - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; - ylist_add(&in->hash_link, &dev->obj_bucket[bucket].list); + list_add(&in->hash_link, &dev->obj_bucket[bucket].list); dev->obj_bucket[bucket].count++; } -yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number) +struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number) { int bucket = yaffs_hash_fn(number); - struct ylist_head *i; - yaffs_obj_t *in; + struct list_head *i; + struct yaffs_obj *in; - ylist_for_each(i, &dev->obj_bucket[bucket].list) { + list_for_each(i, &dev->obj_bucket[bucket].list) { /* Look if it is in the list */ if (i) { - in = ylist_entry(i, yaffs_obj_t, hash_link); + in = list_entry(i, struct yaffs_obj, hash_link); if (in->obj_id == number) { /* Don't tell the VFS about this one if it is defered free */ @@ -1436,11 +1337,11 @@ yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number) return NULL; } -yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, - yaffs_obj_type type) +struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, + enum yaffs_obj_type type) { - yaffs_obj_t *the_obj=NULL; - yaffs_tnode_t *tn = NULL; + struct yaffs_obj *the_obj = NULL; + struct yaffs_tnode *tn = NULL; if (number < 0) number = yaffs_new_obj_id(dev); @@ -1452,13 +1353,12 @@ yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, } the_obj = yaffs_alloc_empty_obj(dev); - if (!the_obj){ - if(tn) - yaffs_free_tnode(dev,tn); + if (!the_obj) { + if (tn) + yaffs_free_tnode(dev, tn); return NULL; } - if (the_obj) { the_obj->fake = 0; the_obj->rename_allowed = 1; @@ -1466,31 +1366,19 @@ yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, the_obj->obj_id = number; yaffs_hash_obj(the_obj); the_obj->variant_type = type; -#ifdef CONFIG_YAFFS_WINCE - yfsd_win_file_time_now(the_obj->win_atime); - the_obj->win_ctime[0] = the_obj->win_mtime[0] = - the_obj->win_atime[0]; - the_obj->win_ctime[1] = the_obj->win_mtime[1] = - the_obj->win_atime[1]; + yaffs_load_current_time(the_obj, 1, 1); -#else - - the_obj->yst_atime = the_obj->yst_mtime = - the_obj->yst_ctime = Y_CURRENT_TIME; -#endif switch (type) { case YAFFS_OBJECT_TYPE_FILE: the_obj->variant.file_variant.file_size = 0; the_obj->variant.file_variant.scanned_size = 0; - the_obj->variant.file_variant.shrink_size = 0xFFFFFFFF; /* max __u32 */ + the_obj->variant.file_variant.shrink_size = ~0; /* max */ the_obj->variant.file_variant.top_level = 0; the_obj->variant.file_variant.top = tn; break; case YAFFS_OBJECT_TYPE_DIRECTORY: - YINIT_LIST_HEAD(&the_obj->variant.dir_variant. - children); - YINIT_LIST_HEAD(&the_obj->variant.dir_variant. - dirty); + INIT_LIST_HEAD(&the_obj->variant.dir_variant.children); + INIT_LIST_HEAD(&the_obj->variant.dir_variant.dirty); break; case YAFFS_OBJECT_TYPE_SYMLINK: case YAFFS_OBJECT_TYPE_HARDLINK: @@ -1506,11 +1394,11 @@ yaffs_obj_t *yaffs_new_obj(yaffs_dev_t *dev, int number, return the_obj; } -yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev, - int number, - yaffs_obj_type type) +struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, + int number, + enum yaffs_obj_type type) { - yaffs_obj_t *the_obj = NULL; + struct yaffs_obj *the_obj = NULL; if (number > 0) the_obj = yaffs_find_by_number(dev, number); @@ -1522,8 +1410,7 @@ yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev, } - -YCHAR *yaffs_clone_str(const YCHAR *str) +YCHAR *yaffs_clone_str(const YCHAR * str) { YCHAR *new_str = NULL; int len; @@ -1531,10 +1418,10 @@ YCHAR *yaffs_clone_str(const YCHAR *str) if (!str) str = _Y(""); - len = yaffs_strnlen(str,YAFFS_MAX_ALIAS_LENGTH); + len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH); new_str = YMALLOC((len + 1) * sizeof(YCHAR)); - if (new_str){ - yaffs_strncpy(new_str, str,len); + if (new_str) { + yaffs_strncpy(new_str, str, len); new_str[len] = 0; } return new_str; @@ -1548,21 +1435,21 @@ YCHAR *yaffs_clone_str(const YCHAR *str) * rdev only has meaning for devices (a subset of special objects) */ -static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type, - yaffs_obj_t *parent, - const YCHAR *name, - __u32 mode, - __u32 uid, - __u32 gid, - yaffs_obj_t *equiv_obj, - const YCHAR *alias_str, __u32 rdev) +static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, + struct yaffs_obj *parent, + const YCHAR * name, + u32 mode, + u32 uid, + u32 gid, + struct yaffs_obj *equiv_obj, + const YCHAR * alias_str, u32 rdev) { - yaffs_obj_t *in; + struct yaffs_obj *in; YCHAR *str = NULL; - yaffs_dev_t *dev = parent->my_dev; + struct yaffs_dev *dev = parent->my_dev; - /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/ + /* Check if the entry exists. If it does then fail the call since we don't want a dup. */ if (yaffs_find_by_name(parent, name)) return NULL; @@ -1574,16 +1461,12 @@ static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type, in = yaffs_new_obj(dev, -1, type); - if (!in){ - if(str) + if (!in) { + if (str) YFREE(str); return NULL; } - - - - if (in) { in->hdr_chunk = 0; in->valid = 1; @@ -1591,18 +1474,8 @@ static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type, in->yst_mode = mode; -#ifdef CONFIG_YAFFS_WINCE - yfsd_win_file_time_now(in->win_atime); - in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0]; - in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1]; - -#else - in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME; + yaffs_attribs_init(in, gid, uid, rdev); - in->yst_rdev = rdev; - in->yst_uid = uid; - in->yst_gid = gid; -#endif in->n_data_chunks = 0; yaffs_set_obj_name(in, name); @@ -1617,11 +1490,10 @@ static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type, in->variant.symlink_variant.alias = str; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardlink_variant.equiv_obj = - equiv_obj; + in->variant.hardlink_variant.equiv_obj = equiv_obj; in->variant.hardlink_variant.equiv_id = - equiv_obj->obj_id; - ylist_add(&in->hard_links, &equiv_obj->hard_links); + equiv_obj->obj_id; + list_add(&in->hard_links, &equiv_obj->hard_links); break; case YAFFS_OBJECT_TYPE_FILE: case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -1643,38 +1515,40 @@ static yaffs_obj_t *yaffs_create_obj(yaffs_obj_type type, return in; } -yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid) +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, uid, gid, NULL, NULL, 0); } -yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid) +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name, + u32 mode, u32 uid, u32 gid) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, - mode, uid, gid, NULL, NULL, 0); + mode, uid, gid, NULL, NULL, 0); } -yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, __u32 rdev) +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, u32 rdev) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, - uid, gid, NULL, NULL, rdev); + uid, gid, NULL, NULL, rdev); } -yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, - const YCHAR *alias) +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, const YCHAR * alias) { return yaffs_create_obj(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, uid, gid, NULL, alias, 0); } /* yaffs_link_obj returns the object id of the equivalent object.*/ -yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name, - yaffs_obj_t *equiv_obj) +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name, + struct yaffs_obj *equiv_obj) { /* Get the real object in case we were fed a hard link as an equivalent object */ equiv_obj = yaffs_get_equivalent_obj(equiv_obj); @@ -1689,13 +1563,14 @@ yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name, } -static int yaffs_change_obj_name(yaffs_obj_t *obj, yaffs_obj_t *new_dir, - const YCHAR *new_name, int force, int shadows) +static int yaffs_change_obj_name(struct yaffs_obj *obj, + struct yaffs_obj *new_dir, + const YCHAR * new_name, int force, int shadows) { int unlink_op; int del_op; - yaffs_obj_t *existing_target; + struct yaffs_obj *existing_target; if (new_dir == NULL) new_dir = obj->parent; /* use the old directory */ @@ -1713,7 +1588,7 @@ static int yaffs_change_obj_name(yaffs_obj_t *obj, yaffs_obj_t *new_dir, unlink_op = (new_dir == obj->my_dev->unlinked_dir); else unlink_op = (new_dir == obj->my_dev->unlinked_dir - && obj->variant_type == YAFFS_OBJECT_TYPE_FILE); + && obj->variant_type == YAFFS_OBJECT_TYPE_FILE); del_op = (new_dir == obj->my_dev->del_dir); @@ -1739,22 +1614,22 @@ static int yaffs_change_obj_name(yaffs_obj_t *obj, yaffs_obj_t *new_dir, obj->unlinked = 1; /* If it is a deletion then we mark it as a shrink for gc purposes. */ - if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= 0) + if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= + 0) return YAFFS_OK; } return YAFFS_FAIL; } -int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, - yaffs_obj_t *new_dir, const YCHAR *new_name) +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, + struct yaffs_obj *new_dir, const YCHAR * new_name) { - yaffs_obj_t *obj = NULL; - yaffs_obj_t *existing_target = NULL; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *existing_target = NULL; int force = 0; int result; - yaffs_dev_t *dev; - + struct yaffs_dev *dev; if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); @@ -1764,15 +1639,16 @@ int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, dev = old_dir->my_dev; #ifdef CONFIG_YAFFS_CASE_INSENSITIVE - /* Special case for case insemsitive systems (eg. WinCE). + /* Special case for case insemsitive systems. * While look-up is case insensitive, the name isn't. * Therefore we might want to change x.txt to X.txt - */ + */ if (old_dir == new_dir && yaffs_strcmp(old_name, new_name) == 0) force = 1; #endif - if(yaffs_strnlen(new_name,YAFFS_MAX_NAME_LENGTH+1) > YAFFS_MAX_NAME_LENGTH) + if (yaffs_strnlen(new_name, YAFFS_MAX_NAME_LENGTH + 1) > + YAFFS_MAX_NAME_LENGTH) /* ENAMETOOLONG */ return YAFFS_FAIL; @@ -1784,8 +1660,9 @@ int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, existing_target = yaffs_find_by_name(new_dir, new_name); if (existing_target && - existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&existing_target->variant.dir_variant.children)) { + existing_target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY + && !list_empty(&existing_target->variant.dir_variant. + children)) { /* There is a target that is a non-empty directory, so we fail */ return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */ } else if (existing_target && existing_target != obj) { @@ -1795,20 +1672,20 @@ int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, * Note we must disable gc otherwise it can mess up the shadowing. * */ - dev->gc_disable=1; + dev->gc_disable = 1; yaffs_change_obj_name(obj, new_dir, new_name, force, - existing_target->obj_id); + existing_target->obj_id); existing_target->is_shadowed = 1; yaffs_unlink_obj(existing_target); - dev->gc_disable=0; + dev->gc_disable = 0; } result = yaffs_change_obj_name(obj, new_dir, new_name, 1, 0); yaffs_update_parent(old_dir); - if(new_dir != old_dir) + if (new_dir != old_dir) yaffs_update_parent(new_dir); - + return result; } return YAFFS_FAIL; @@ -1816,7 +1693,7 @@ int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, /*------------------------- Block Management and Page Allocation ----------------*/ -static int yaffs_init_blocks(yaffs_dev_t *dev) +static int yaffs_init_blocks(struct yaffs_dev *dev) { int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; @@ -1826,26 +1703,29 @@ static int yaffs_init_blocks(yaffs_dev_t *dev) dev->alloc_block = -1; /* force it to get a new one */ /* If the first allocation strategy fails, thry the alternate one */ - dev->block_info = YMALLOC(n_blocks * sizeof(yaffs_block_info_t)); + dev->block_info = YMALLOC(n_blocks * sizeof(struct yaffs_block_info)); if (!dev->block_info) { - dev->block_info = YMALLOC_ALT(n_blocks * sizeof(yaffs_block_info_t)); + dev->block_info = + YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_info)); dev->block_info_alt = 1; } else dev->block_info_alt = 0; if (dev->block_info) { /* Set up dynamic blockinfo stuff. */ - dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */ + dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; /* round up bytes */ dev->chunk_bits = YMALLOC(dev->chunk_bit_stride * n_blocks); if (!dev->chunk_bits) { - dev->chunk_bits = YMALLOC_ALT(dev->chunk_bit_stride * n_blocks); + dev->chunk_bits = + YMALLOC_ALT(dev->chunk_bit_stride * n_blocks); dev->chunk_bits_alt = 1; } else dev->chunk_bits_alt = 0; } if (dev->block_info && dev->chunk_bits) { - memset(dev->block_info, 0, n_blocks * sizeof(yaffs_block_info_t)); + memset(dev->block_info, 0, + n_blocks * sizeof(struct yaffs_block_info)); memset(dev->chunk_bits, 0, dev->chunk_bit_stride * n_blocks); return YAFFS_OK; } @@ -1853,7 +1733,7 @@ static int yaffs_init_blocks(yaffs_dev_t *dev) return YAFFS_FAIL; } -static void yaffs_deinit_blocks(yaffs_dev_t *dev) +static void yaffs_deinit_blocks(struct yaffs_dev *dev) { if (dev->block_info_alt && dev->block_info) YFREE_ALT(dev->block_info); @@ -1872,9 +1752,9 @@ static void yaffs_deinit_blocks(yaffs_dev_t *dev) dev->chunk_bits = NULL; } -void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no) +void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) { - yaffs_block_info_t *bi = yaffs_get_block_info(dev, block_no); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, block_no); int erased_ok = 0; @@ -1883,19 +1763,20 @@ void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no) */ T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE, - (TSTR("yaffs_block_became_dirty block %d state %d %s"TENDSTR), - block_no, bi->block_state, (bi->needs_retiring) ? "needs retiring" : "")); + (TSTR("yaffs_block_became_dirty block %d state %d %s" TENDSTR), + block_no, bi->block_state, + (bi->needs_retiring) ? "needs retiring" : "")); - yaffs2_clear_oldest_dirty_seq(dev,bi); + yaffs2_clear_oldest_dirty_seq(dev, bi); bi->block_state = YAFFS_BLOCK_STATE_DIRTY; /* If this is the block being garbage collected then stop gc'ing this block */ - if(block_no == dev->gc_block) + if (block_no == dev->gc_block) dev->gc_block = 0; /* If this block is currently the best candidate for gc then drop as a candidate */ - if(block_no == dev->gc_dirtiest){ + if (block_no == dev->gc_dirtiest) { dev->gc_dirtiest = 0; dev->gc_pages_in_use = 0; } @@ -1911,7 +1792,8 @@ void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no) } if (erased_ok && - ((yaffs_trace_mask & YAFFS_TRACE_ERASE) || !yaffs_skip_verification(dev))) { + ((yaffs_trace_mask & YAFFS_TRACE_ERASE) + || !yaffs_skip_verification(dev))) { int i; for (i = 0; i < dev->param.chunks_per_block; i++) { if (!yaffs_check_chunk_erased @@ -1932,7 +1814,7 @@ void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no) bi->pages_in_use = 0; bi->soft_del_pages = 0; bi->has_shrink_hdr = 0; - bi->skip_erased_check = 1; /* This is clean, so no need to check */ + bi->skip_erased_check = 1; /* This is clean, so no need to check */ bi->gc_prioritise = 0; yaffs_clear_chunk_bits(dev, block_no); @@ -1947,11 +1829,11 @@ void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no) } } -static int yaffs_find_alloc_block(yaffs_dev_t *dev) +static int yaffs_find_alloc_block(struct yaffs_dev *dev) { int i; - yaffs_block_info_t *bi; + struct yaffs_block_info *bi; if (dev->n_erased_blocks < 1) { /* Hoosterman we've got a problem. @@ -1995,12 +1877,11 @@ static int yaffs_find_alloc_block(yaffs_dev_t *dev) return -1; } - /* * Check if there's space to allocate... * Thinks.... do we need top make this ths same as yaffs_get_free_chunks()? */ -int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks) +int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks) { int reserved_chunks; int reserved_blocks = dev->param.n_reserved_blocks; @@ -2008,16 +1889,17 @@ int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks) checkpt_blocks = yaffs_calc_checkpt_blocks_required(dev); - reserved_chunks = ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block); + reserved_chunks = + ((reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block); return (dev->n_free_chunks > (reserved_chunks + n_chunks)); } -static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver, - yaffs_block_info_t **block_ptr) +static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, + struct yaffs_block_info **block_ptr) { int ret_val; - yaffs_block_info_t *bi; + struct yaffs_block_info *bi; if (dev->alloc_block < 0) { /* Get next block to allocate off */ @@ -2031,7 +1913,7 @@ static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver, } if (dev->n_erased_blocks < dev->param.n_reserved_blocks - && dev->alloc_page == 0) { + && dev->alloc_page == 0) { T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); } @@ -2040,10 +1922,9 @@ static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver, bi = yaffs_get_block_info(dev, dev->alloc_block); ret_val = (dev->alloc_block * dev->param.chunks_per_block) + - dev->alloc_page; + dev->alloc_page; bi->pages_in_use++; - yaffs_set_chunk_bit(dev, dev->alloc_block, - dev->alloc_page); + yaffs_set_chunk_bit(dev, dev->alloc_block, dev->alloc_page); dev->alloc_page++; @@ -2062,12 +1943,12 @@ static int yaffs_alloc_chunk(yaffs_dev_t *dev, int use_reserver, } T(YAFFS_TRACE_ERROR, - (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); + (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); return -1; } -static int yaffs_get_erased_chunks(yaffs_dev_t *dev) +static int yaffs_get_erased_chunks(struct yaffs_dev *dev) { int n; @@ -2084,20 +1965,19 @@ static int yaffs_get_erased_chunks(yaffs_dev_t *dev) * yaffs_skip_rest_of_block() skips over the rest of the allocation block * if we don't want to write to it. */ -void yaffs_skip_rest_of_block(yaffs_dev_t *dev) +void yaffs_skip_rest_of_block(struct yaffs_dev *dev) { - if(dev->alloc_block > 0){ - yaffs_block_info_t *bi = yaffs_get_block_info(dev, dev->alloc_block); - if(bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING){ + if (dev->alloc_block > 0) { + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, dev->alloc_block); + if (bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING) { bi->block_state = YAFFS_BLOCK_STATE_FULL; dev->alloc_block = -1; } } } - -static int yaffs_gc_block(yaffs_dev_t *dev, int block, - int whole_block) +static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) { int old_chunk; int new_chunk; @@ -2111,53 +1991,49 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, int chunks_before = yaffs_get_erased_chunks(dev); int chunks_after; - yaffs_ext_tags tags; + struct yaffs_ext_tags tags; - yaffs_block_info_t *bi = yaffs_get_block_info(dev, block); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, block); - yaffs_obj_t *object; + struct yaffs_obj *object; is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT); - T(YAFFS_TRACE_TRACING, - (TSTR("Collecting block %d, in use %d, shrink %d, whole_block %d" TENDSTR), - block, - bi->pages_in_use, - bi->has_shrink_hdr, - whole_block)); + (TSTR + ("Collecting block %d, in use %d, shrink %d, whole_block %d" + TENDSTR), block, bi->pages_in_use, bi->has_shrink_hdr, + whole_block)); /*yaffs_verify_free_chunks(dev); */ - if(bi->block_state == YAFFS_BLOCK_STATE_FULL) + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) bi->block_state = YAFFS_BLOCK_STATE_COLLECTING; - + bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */ dev->gc_disable = 1; - if (is_checkpt_block || - !yaffs_still_some_chunks(dev, block)) { + if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) { T(YAFFS_TRACE_TRACING, - (TSTR - ("Collecting block %d that has no chunks in use" TENDSTR), - block)); + (TSTR + ("Collecting block %d that has no chunks in use" TENDSTR), + block)); yaffs_block_became_dirty(dev, block); } else { - __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); yaffs_verify_blk(dev, bi, block); max_copies = (whole_block) ? dev->param.chunks_per_block : 5; old_chunk = block * dev->param.chunks_per_block + dev->gc_chunk; - for (/* init already done */; + for ( /* init already done */ ; ret_val == YAFFS_OK && dev->gc_chunk < dev->param.chunks_per_block && (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) && - max_copies > 0; - dev->gc_chunk++, old_chunk++) { + max_copies > 0; dev->gc_chunk++, old_chunk++) { if (yaffs_check_chunk_bit(dev, block, dev->gc_chunk)) { /* This page is in use and might need to be copied off */ @@ -2169,30 +2045,35 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, yaffs_init_tags(&tags); yaffs_rd_chunk_tags_nand(dev, old_chunk, - buffer, &tags); + buffer, &tags); - object = - yaffs_find_by_number(dev, - tags.obj_id); + object = yaffs_find_by_number(dev, tags.obj_id); T(YAFFS_TRACE_GC_DETAIL, (TSTR - ("Collecting chunk in block %d, %d %d %d " TENDSTR), - dev->gc_chunk, tags.obj_id, tags.chunk_id, - tags.n_bytes)); + ("Collecting chunk in block %d, %d %d %d " + TENDSTR), dev->gc_chunk, tags.obj_id, + tags.chunk_id, tags.n_bytes)); if (object && !yaffs_skip_verification(dev)) { if (tags.chunk_id == 0) - matching_chunk = object->hdr_chunk; + matching_chunk = + object->hdr_chunk; else if (object->soft_del) - matching_chunk = old_chunk; /* Defeat the test */ + matching_chunk = old_chunk; /* Defeat the test */ else - matching_chunk = yaffs_find_chunk_in_file(object, tags.chunk_id, NULL); + matching_chunk = + yaffs_find_chunk_in_file + (object, tags.chunk_id, + NULL); if (old_chunk != matching_chunk) T(YAFFS_TRACE_ERROR, - (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR), - old_chunk, matching_chunk, tags.obj_id, tags.chunk_id)); + (TSTR + ("gc: page in gc mismatch: %d %d %d %d" + TENDSTR), old_chunk, + matching_chunk, tags.obj_id, + tags.chunk_id)); } @@ -2201,19 +2082,19 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, (TSTR ("page %d in gc has no object: %d %d %d " TENDSTR), old_chunk, - tags.obj_id, tags.chunk_id, tags.n_bytes)); + tags.obj_id, tags.chunk_id, + tags.n_bytes)); } if (object && object->deleted && - object->soft_del && - tags.chunk_id != 0) { + object->soft_del && tags.chunk_id != 0) { /* Data chunk in a soft deleted file, throw it away * It's a soft deleted data chunk, * No need to copy this, just forget about it and * fix up the object. */ - + /* Free chunks already includes softdeleted chunks. * How ever this chunk is going to soon be really deleted * which will increment free chunks. @@ -2226,8 +2107,9 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, if (object->n_data_chunks <= 0) { /* remeber to clean up the object */ - dev->gc_cleanup_list[dev->n_clean_ups] = - tags.obj_id; + dev->gc_cleanup_list[dev-> + n_clean_ups] + = tags.obj_id; dev->n_clean_ups++; } mark_flash = 0; @@ -2238,8 +2120,9 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, */ object->hdr_chunk = 0; yaffs_free_tnode(object->my_dev, - object->variant. - file_variant.top); + object-> + variant.file_variant. + top); object->variant.file_variant.top = NULL; yaffs_generic_obj_del(object); @@ -2261,8 +2144,9 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, * and if it is left in place it will mess up scanning. */ - yaffs_obj_header *oh; - oh = (yaffs_obj_header *)buffer; + struct yaffs_obj_hdr *oh; + oh = (struct yaffs_obj_hdr *) + buffer; oh->is_shrink = 0; tags.extra_is_shrink = 0; @@ -2272,17 +2156,30 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, tags.extra_shadows = 0; /* Update file size */ - if(object->variant_type == YAFFS_OBJECT_TYPE_FILE){ - oh->file_size = object->variant.file_variant.file_size; - tags.extra_length = oh->file_size; + if (object->variant_type == + YAFFS_OBJECT_TYPE_FILE) { + oh->file_size = + object->variant. + file_variant. + file_size; + tags.extra_length = + oh->file_size; } - yaffs_verify_oh(object, oh, &tags, 1); + yaffs_verify_oh(object, oh, + &tags, 1); new_chunk = - yaffs_write_new_chunk(dev,(__u8 *) oh, &tags, 1); + yaffs_write_new_chunk(dev, + (u8 *) + oh, + &tags, + 1); } else new_chunk = - yaffs_write_new_chunk(dev, buffer, &tags, 1); + yaffs_write_new_chunk(dev, + buffer, + &tags, + 1); if (new_chunk < 0) { ret_val = YAFFS_FAIL; @@ -2292,35 +2189,31 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, if (tags.chunk_id == 0) { /* It's a header */ - object->hdr_chunk = new_chunk; - object->serial = tags.serial_number; + object->hdr_chunk = + new_chunk; + object->serial = + tags.serial_number; } else { /* It's a data chunk */ int ok; - ok = yaffs_put_chunk_in_file - (object, - tags.chunk_id, - new_chunk, 0); + ok = yaffs_put_chunk_in_file(object, tags.chunk_id, new_chunk, 0); } } } if (ret_val == YAFFS_OK) - yaffs_chunk_del(dev, old_chunk, mark_flash, __LINE__); + yaffs_chunk_del(dev, old_chunk, + mark_flash, __LINE__); } } yaffs_release_temp_buffer(dev, buffer, __LINE__); - - } yaffs_verify_collected_blk(dev, bi, block); - - if (bi->block_state == YAFFS_BLOCK_STATE_COLLECTING) { /* * The gc did not complete. Set block state back to FULL @@ -2333,12 +2226,11 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, for (i = 0; i < dev->n_clean_ups; i++) { /* Time to delete the file too */ object = - yaffs_find_by_number(dev, - dev->gc_cleanup_list[i]); + yaffs_find_by_number(dev, dev->gc_cleanup_list[i]); if (object) { yaffs_free_tnode(dev, - object->variant.file_variant. - top); + object->variant. + file_variant.top); object->variant.file_variant.top = NULL; T(YAFFS_TRACE_GC, (TSTR @@ -2350,7 +2242,6 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, } - chunks_after = yaffs_get_erased_chunks(dev); if (chunks_before >= chunks_after) { T(YAFFS_TRACE_GC, @@ -2373,16 +2264,15 @@ static int yaffs_gc_block(yaffs_dev_t *dev, int block, * for garbage collection. */ -static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, - int aggressive, - int background) +static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, + int aggressive, int background) { int i; int iterations; unsigned selected = 0; int prioritised = 0; int prioritised_exist = 0; - yaffs_block_info_t *bi; + struct yaffs_block_info *bi; int threshold; /* First let's see if we need to grab a prioritised block */ @@ -2390,13 +2280,12 @@ static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, dev->gc_dirtiest = 0; bi = dev->block_info; for (i = dev->internal_start_block; - i <= dev->internal_end_block && !selected; - i++) { + i <= dev->internal_end_block && !selected; i++) { if (bi->gc_prioritise) { prioritised_exist = 1; if (bi->block_state == YAFFS_BLOCK_STATE_FULL && - yaffs_block_ok_for_gc(dev, bi)) { + yaffs_block_ok_for_gc(dev, bi)) { selected = i; prioritised = 1; } @@ -2410,12 +2299,11 @@ static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, * up the works. Let's gc the oldest dirty block. */ - if(prioritised_exist && - !selected && - dev->oldest_dirty_block > 0) + if (prioritised_exist && + !selected && dev->oldest_dirty_block > 0) selected = dev->oldest_dirty_block; - if (!prioritised_exist) /* None found, so we can clear this */ + if (!prioritised_exist) /* None found, so we can clear this */ dev->has_pending_prioritised_gc = 0; } @@ -2425,28 +2313,28 @@ static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, * block has only a few pages in use. */ - if (!selected){ + if (!selected) { int pages_used; - int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; - if (aggressive){ + int n_blocks = + dev->internal_end_block - dev->internal_start_block + 1; + if (aggressive) { threshold = dev->param.chunks_per_block; iterations = n_blocks; } else { int max_threshold; - if(background) - max_threshold = dev->param.chunks_per_block/2; + if (background) + max_threshold = dev->param.chunks_per_block / 2; else - max_threshold = dev->param.chunks_per_block/8; + max_threshold = dev->param.chunks_per_block / 8; - if(max_threshold < YAFFS_GC_PASSIVE_THRESHOLD) + if (max_threshold < YAFFS_GC_PASSIVE_THRESHOLD) max_threshold = YAFFS_GC_PASSIVE_THRESHOLD; - threshold = background ? - (dev->gc_not_done + 2) * 2 : 0; - if(threshold gc_not_done + 2) * 2 : 0; + if (threshold < YAFFS_GC_PASSIVE_THRESHOLD) threshold = YAFFS_GC_PASSIVE_THRESHOLD; - if(threshold > max_threshold) + if (threshold > max_threshold) threshold = max_threshold; iterations = n_blocks / 16 + 1; @@ -2455,29 +2343,30 @@ static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, } for (i = 0; - i < iterations && - (dev->gc_dirtiest < 1 || - dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); - i++) { + i < iterations && + (dev->gc_dirtiest < 1 || + dev->gc_pages_in_use > YAFFS_GC_GOOD_ENOUGH); i++) { dev->gc_block_finder++; if (dev->gc_block_finder < dev->internal_start_block || - dev->gc_block_finder > dev->internal_end_block) - dev->gc_block_finder = dev->internal_start_block; + dev->gc_block_finder > dev->internal_end_block) + dev->gc_block_finder = + dev->internal_start_block; bi = yaffs_get_block_info(dev, dev->gc_block_finder); pages_used = bi->pages_in_use - bi->soft_del_pages; if (bi->block_state == YAFFS_BLOCK_STATE_FULL && - pages_used < dev->param.chunks_per_block && - (dev->gc_dirtiest < 1 || pages_used < dev->gc_pages_in_use) && - yaffs_block_ok_for_gc(dev, bi)) { + pages_used < dev->param.chunks_per_block && + (dev->gc_dirtiest < 1 + || pages_used < dev->gc_pages_in_use) + && yaffs_block_ok_for_gc(dev, bi)) { dev->gc_dirtiest = dev->gc_block_finder; dev->gc_pages_in_use = pages_used; } } - if(dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) + if (dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) selected = dev->gc_dirtiest; } @@ -2486,44 +2375,45 @@ static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, * because that's gumming up the works. */ - if(!selected && dev->param.is_yaffs2 && - dev->gc_not_done >= ( background ? 10 : 20)){ + if (!selected && dev->param.is_yaffs2 && + dev->gc_not_done >= (background ? 10 : 20)) { yaffs2_find_oldest_dirty_seq(dev); - if(dev->oldest_dirty_block > 0) { + if (dev->oldest_dirty_block > 0) { selected = dev->oldest_dirty_block; dev->gc_dirtiest = selected; dev->oldest_dirty_gc_count++; bi = yaffs_get_block_info(dev, selected); - dev->gc_pages_in_use = bi->pages_in_use - bi->soft_del_pages; + dev->gc_pages_in_use = + bi->pages_in_use - bi->soft_del_pages; } else dev->gc_not_done = 0; } - if(selected){ + if (selected) { T(YAFFS_TRACE_GC, - (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), - selected, - dev->param.chunks_per_block - dev->gc_pages_in_use, - prioritised)); + (TSTR + ("GC Selected block %d with %d free, prioritised:%d" + TENDSTR), selected, + dev->param.chunks_per_block - dev->gc_pages_in_use, + prioritised)); dev->n_gc_blocks++; - if(background) + if (background) dev->bg_gcs++; dev->gc_dirtiest = 0; dev->gc_pages_in_use = 0; dev->gc_not_done = 0; - if(dev->refresh_skip > 0) + if (dev->refresh_skip > 0) dev->refresh_skip--; - } else{ + } else { dev->gc_not_done++; T(YAFFS_TRACE_GC, - (TSTR("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" TENDSTR), - dev->gc_block_finder, dev->gc_not_done, - threshold, - dev->gc_dirtiest, dev->gc_pages_in_use, - dev->oldest_dirty_block, - background ? " bg" : "")); + (TSTR + ("GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s" + TENDSTR), dev->gc_block_finder, dev->gc_not_done, threshold, + dev->gc_dirtiest, dev->gc_pages_in_use, + dev->oldest_dirty_block, background ? " bg" : "")); } return selected; @@ -2538,7 +2428,7 @@ static unsigned yaffs_find_gc_block(yaffs_dev_t *dev, * The idea is to help clear out space in a more spread-out manner. * Dunno if it really does anything useful. */ -static int yaffs_check_gc(yaffs_dev_t *dev, int background) +static int yaffs_check_gc(struct yaffs_dev *dev, int background) { int aggressive = 0; int gc_ok = YAFFS_OK; @@ -2547,8 +2437,7 @@ static int yaffs_check_gc(yaffs_dev_t *dev, int background) int erased_chunks; int checkpt_block_adjust; - if(dev->param.gc_control && - (dev->param.gc_control(dev) & 1) == 0) + if (dev->param.gc_control && (dev->param.gc_control(dev) & 1) == 0) return YAFFS_OK; if (dev->gc_disable) { @@ -2565,21 +2454,23 @@ static int yaffs_check_gc(yaffs_dev_t *dev, int background) checkpt_block_adjust = yaffs_calc_checkpt_blocks_required(dev); - min_erased = dev->param.n_reserved_blocks + checkpt_block_adjust + 1; - erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + min_erased = + dev->param.n_reserved_blocks + checkpt_block_adjust + 1; + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; - /* If we need a block soon then do aggressive gc.*/ + /* If we need a block soon then do aggressive gc. */ if (dev->n_erased_blocks < min_erased) aggressive = 1; else { - if(!background && erased_chunks > (dev->n_free_chunks / 4)) + if (!background + && erased_chunks > (dev->n_free_chunks / 4)) break; - if(dev->gc_skip > 20) + if (dev->gc_skip > 20) dev->gc_skip = 20; - if(erased_chunks < dev->n_free_chunks/2 || - dev->gc_skip < 1 || - background) + if (erased_chunks < dev->n_free_chunks / 2 || + dev->gc_skip < 1 || background) aggressive = 0; else { dev->gc_skip--; @@ -2589,17 +2480,18 @@ static int yaffs_check_gc(yaffs_dev_t *dev, int background) dev->gc_skip = 5; - /* If we don't already have a block being gc'd then see if we should start another */ + /* If we don't already have a block being gc'd then see if we should start another */ if (dev->gc_block < 1 && !aggressive) { dev->gc_block = yaffs2_find_refresh_block(dev); dev->gc_chunk = 0; - dev->n_clean_ups=0; + dev->n_clean_ups = 0; } if (dev->gc_block < 1) { - dev->gc_block = yaffs_find_gc_block(dev, aggressive, background); + dev->gc_block = + yaffs_find_gc_block(dev, aggressive, background); dev->gc_chunk = 0; - dev->n_clean_ups=0; + dev->n_clean_ups = 0; } if (dev->gc_block > 0) { @@ -2609,21 +2501,22 @@ static int yaffs_check_gc(yaffs_dev_t *dev, int background) T(YAFFS_TRACE_GC, (TSTR - ("yaffs: GC n_erased_blocks %d aggressive %d" TENDSTR), - dev->n_erased_blocks, aggressive)); + ("yaffs: GC n_erased_blocks %d aggressive %d" + TENDSTR), dev->n_erased_blocks, aggressive)); gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive); } - if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) && dev->gc_block > 0) { + if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) + && dev->gc_block > 0) { T(YAFFS_TRACE_GC, (TSTR ("yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d" - TENDSTR), dev->n_erased_blocks, max_tries, dev->gc_block)); + TENDSTR), dev->n_erased_blocks, max_tries, + dev->gc_block)); } } while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) && - (dev->gc_block > 0) && - (max_tries < 2)); + (dev->gc_block > 0) && (max_tries < 2)); return aggressive ? gc_ok : YAFFS_OK; } @@ -2633,39 +2526,38 @@ static int yaffs_check_gc(yaffs_dev_t *dev, int background) * Garbage collects. Intended to be called from a background thread. * Returns non-zero if at least half the free chunks are erased. */ -int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency) +int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency) { int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR),urgency)); + T(YAFFS_TRACE_BACKGROUND, (TSTR("Background gc %u" TENDSTR), urgency)); yaffs_check_gc(dev, 1); - return erased_chunks > dev->n_free_chunks/2; + return erased_chunks > dev->n_free_chunks / 2; } /*------------------------- TAGS --------------------------------*/ -static int yaffs_tags_match(const yaffs_ext_tags *tags, int obj_id, - int chunk_obj) +static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, + int chunk_obj) { return (tags->chunk_id == chunk_obj && tags->obj_id == obj_id && !tags->is_deleted) ? 1 : 0; } - /*-------------------- Data file manipulation -----------------*/ -static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk, - yaffs_ext_tags *tags) +static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags) { /*Get the Tnode, then get the level 0 offset chunk offset */ - yaffs_tnode_t *tn; + struct yaffs_tnode *tn; int the_chunk = -1; - yaffs_ext_tags local_tags; + struct yaffs_ext_tags local_tags; int ret_val = -1; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; if (!tags) { /* Passed a NULL, so use our own tags space */ @@ -2679,20 +2571,20 @@ static int yaffs_find_chunk_in_file(yaffs_obj_t *in, int inode_chunk, ret_val = yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id, - inode_chunk); + inode_chunk); } return ret_val; } -static int yaffs_find_del_file_chunk(yaffs_obj_t *in, int inode_chunk, - yaffs_ext_tags *tags) +static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags) { /* Get the Tnode, then get the level 0 offset chunk offset */ - yaffs_tnode_t *tn; + struct yaffs_tnode *tn; int the_chunk = -1; - yaffs_ext_tags local_tags; + struct yaffs_ext_tags local_tags; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; int ret_val = -1; if (!tags) { @@ -2708,7 +2600,7 @@ static int yaffs_find_del_file_chunk(yaffs_obj_t *in, int inode_chunk, ret_val = yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id, - inode_chunk); + inode_chunk); /* Delete the entry in the filestructure (if found) */ if (ret_val != -1) @@ -2718,9 +2610,8 @@ static int yaffs_find_del_file_chunk(yaffs_obj_t *in, int inode_chunk, return ret_val; } - -int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, - int nand_chunk, int in_scan) +int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + int nand_chunk, int in_scan) { /* NB in_scan is zero unless scanning. * For forward scanning, in_scan is > 0; @@ -2729,11 +2620,11 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, * nand_chunk = 0 is a dummy insert to make sure the tnodes are there. */ - yaffs_tnode_t *tn; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_tnode *tn; + struct yaffs_dev *dev = in->my_dev; int existing_cunk; - yaffs_ext_tags existing_tags; - yaffs_ext_tags new_tags; + struct yaffs_ext_tags existing_tags; + struct yaffs_ext_tags new_tags; unsigned existing_serial, new_serial; if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) { @@ -2753,13 +2644,12 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, } tn = yaffs_add_find_tnode_0(dev, - &in->variant.file_variant, - inode_chunk, - NULL); + &in->variant.file_variant, + inode_chunk, NULL); if (!tn) return YAFFS_FAIL; - - if(!nand_chunk) + + if (!nand_chunk) /* Dummy insert, bail now */ return YAFFS_OK; @@ -2789,13 +2679,13 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, if (in_scan > 0) { /* Only do this for forward scanning */ yaffs_rd_chunk_tags_nand(dev, - nand_chunk, - NULL, &new_tags); + nand_chunk, + NULL, &new_tags); /* Do a proper find */ existing_cunk = yaffs_find_chunk_in_file(in, inode_chunk, - &existing_tags); + &existing_tags); } if (existing_cunk <= 0) { @@ -2825,14 +2715,13 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, * Delete the old one and drop through to update the tnode */ yaffs_chunk_del(dev, existing_cunk, 1, - __LINE__); + __LINE__); } else { /* Backward scanning or we want to use the existing one * Use existing. * Delete the new one and return early so that the tnode isn't changed */ - yaffs_chunk_del(dev, nand_chunk, 1, - __LINE__); + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; } } @@ -2847,8 +2736,7 @@ int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, return YAFFS_OK; } -static int yaffs_rd_data_obj(yaffs_obj_t *in, int inode_chunk, - __u8 *buffer) +static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer) { int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL); @@ -2866,12 +2754,13 @@ static int yaffs_rd_data_obj(yaffs_obj_t *in, int inode_chunk, } -void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn) +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn) { int block; int page; - yaffs_ext_tags tags; - yaffs_block_info_t *bi; + struct yaffs_ext_tags tags; + struct yaffs_block_info *bi; if (chunk_id <= 0) return; @@ -2880,14 +2769,12 @@ void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn) block = chunk_id / dev->param.chunks_per_block; page = chunk_id % dev->param.chunks_per_block; - if (!yaffs_check_chunk_bit(dev, block, page)) T(YAFFS_TRACE_VERIFY, - (TSTR("Deleting invalid chunk %d"TENDSTR), - chunk_id)); + (TSTR("Deleting invalid chunk %d" TENDSTR), chunk_id)); bi = yaffs_get_block_info(dev, block); - + yaffs2_update_oldest_dirty_seq(dev, block, bi); T(YAFFS_TRACE_DELETION, @@ -2930,9 +2817,8 @@ void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn) } -static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk, - const __u8 *buffer, int n_bytes, - int use_reserve) +static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, + const u8 * buffer, int n_bytes, int use_reserve) { /* Find old chunk Need to do this to get serial number * Write new one and patch into tree. @@ -2940,22 +2826,22 @@ static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk, */ int prev_chunk_id; - yaffs_ext_tags prev_tags; + struct yaffs_ext_tags prev_tags; int new_chunk_id; - yaffs_ext_tags new_tags; + struct yaffs_ext_tags new_tags; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; - yaffs_check_gc(dev,0); + yaffs_check_gc(dev, 0); /* Get the previous chunk at this location in the file if it exists. * If it does not exist then put a zero into the tree. This creates * the tnode now, rather than later when it is harder to clean up. */ prev_chunk_id = yaffs_find_chunk_in_file(in, inode_chunk, &prev_tags); - if(prev_chunk_id < 1 && - !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0)) + if (prev_chunk_id < 1 && + !yaffs_put_chunk_in_file(in, inode_chunk, 0, 0)) return 0; /* Set up new tags */ @@ -2969,14 +2855,13 @@ static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk, if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) { T(YAFFS_TRACE_ERROR, - (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), n_bytes)); + (TSTR("Writing %d bytes to chunk!!!!!!!!!" TENDSTR), + n_bytes)); YBUG(); } - - + new_chunk_id = - yaffs_write_new_chunk(dev, buffer, &new_tags, - use_reserve); + yaffs_write_new_chunk(dev, buffer, &new_tags, use_reserve); if (new_chunk_id > 0) { yaffs_put_chunk_in_file(in, inode_chunk, new_chunk_id, 0); @@ -2993,51 +2878,49 @@ static int yaffs_wr_data_obj(yaffs_obj_t *in, int inode_chunk, /* UpdateObjectHeader updates the header on NAND for an object. * If name is not NULL, then that new name is used. */ -int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, - int is_shrink, int shadows, yaffs_xattr_mod *xmod) +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, int force, + int is_shrink, int shadows, struct yaffs_xattr_mod *xmod) { - yaffs_block_info_t *bi; + struct yaffs_block_info *bi; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; int prev_chunk_id; int ret_val = 0; int result = 0; int new_chunk_id; - yaffs_ext_tags new_tags; - yaffs_ext_tags old_tags; + struct yaffs_ext_tags new_tags; + struct yaffs_ext_tags old_tags; const YCHAR *alias = NULL; - __u8 *buffer = NULL; + u8 *buffer = NULL; YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1]; - yaffs_obj_header *oh = NULL; + struct yaffs_obj_hdr *oh = NULL; yaffs_strcpy(old_name, _Y("silly old name")); + if (!in->fake || in == dev->root_dir || /* The root_dir should also be saved */ + force || xmod) { - if (!in->fake || - in == dev->root_dir || /* The root_dir should also be saved */ - force || xmod) { - - yaffs_check_gc(dev,0); + yaffs_check_gc(dev, 0); yaffs_check_obj_details_loaded(in); buffer = yaffs_get_temp_buffer(in->my_dev, __LINE__); - oh = (yaffs_obj_header *) buffer; + oh = (struct yaffs_obj_hdr *)buffer; prev_chunk_id = in->hdr_chunk; if (prev_chunk_id > 0) { result = yaffs_rd_chunk_tags_nand(dev, prev_chunk_id, - buffer, &old_tags); + buffer, &old_tags); yaffs_verify_oh(in, oh, &old_tags, 0); memcpy(old_name, oh->name, sizeof(oh->name)); - memset(buffer, 0xFF, sizeof(yaffs_obj_header)); + memset(buffer, 0xFF, sizeof(struct yaffs_obj_hdr)); } else memset(buffer, 0xFF, dev->data_bytes_per_chunk); @@ -3045,21 +2928,8 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, oh->yst_mode = in->yst_mode; oh->shadows_obj = oh->inband_shadowed_obj_id = shadows; -#ifdef CONFIG_YAFFS_WINCE - oh->win_atime[0] = in->win_atime[0]; - oh->win_ctime[0] = in->win_ctime[0]; - oh->win_mtime[0] = in->win_mtime[0]; - oh->win_atime[1] = in->win_atime[1]; - oh->win_ctime[1] = in->win_ctime[1]; - oh->win_mtime[1] = in->win_mtime[1]; -#else - oh->yst_uid = in->yst_uid; - oh->yst_gid = in->yst_gid; - oh->yst_atime = in->yst_atime; - oh->yst_mtime = in->yst_mtime; - oh->yst_ctime = in->yst_ctime; - oh->yst_rdev = in->yst_rdev; -#endif + yaffs_load_attribs_oh(oh, in); + if (in->parent) oh->parent_obj_id = in->parent->obj_id; else @@ -3067,7 +2937,7 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, if (name && *name) { memset(oh->name, 0, sizeof(oh->name)); - yaffs_load_oh_from_name(dev,oh->name,name); + yaffs_load_oh_from_name(dev, oh->name, name); } else if (prev_chunk_id > 0) memcpy(oh->name, old_name, sizeof(oh->name)); else @@ -3083,12 +2953,11 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, oh->file_size = (oh->parent_obj_id == YAFFS_OBJECTID_DELETED || oh->parent_obj_id == - YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. - file_variant.file_size; + YAFFS_OBJECTID_UNLINKED) ? 0 : in-> + variant.file_variant.file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - oh->equiv_id = - in->variant.hardlink_variant.equiv_id; + oh->equiv_id = in->variant.hardlink_variant.equiv_id; break; case YAFFS_OBJECT_TYPE_SPECIAL: /* Do nothing */ @@ -3098,20 +2967,17 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, break; case YAFFS_OBJECT_TYPE_SYMLINK: alias = in->variant.symlink_variant.alias; - if(!alias) + if (!alias) alias = _Y("no alias"); - yaffs_strncpy(oh->alias, - alias, - YAFFS_MAX_ALIAS_LENGTH); + yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH); oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; break; } /* process any xattrib modifications */ - if(xmod) + if (xmod) yaffs_apply_xattrib_mod(in, (char *)buffer, xmod); - /* Tags */ yaffs_init_tags(&new_tags); in->serial++; @@ -3134,7 +3000,7 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, /* Create new chunk in NAND */ new_chunk_id = yaffs_write_new_chunk(dev, buffer, &new_tags, - (prev_chunk_id > 0) ? 1 : 0); + (prev_chunk_id > 0) ? 1 : 0); if (new_chunk_id >= 0) { @@ -3142,7 +3008,7 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, if (prev_chunk_id > 0) { yaffs_chunk_del(dev, prev_chunk_id, 1, - __LINE__); + __LINE__); } if (!yaffs_obj_cache_dirty(in)) @@ -3151,7 +3017,9 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, /* If this was a shrink, then mark the block that the chunk lives on */ if (is_shrink) { bi = yaffs_get_block_info(in->my_dev, - new_chunk_id / in->my_dev->param.chunks_per_block); + new_chunk_id / + in->my_dev->param. + chunks_per_block); bi->has_shrink_hdr = 1; } @@ -3168,42 +3036,40 @@ int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, int force, } /*------------------------ Short Operations Cache ---------------------------------------- - * In many situations where there is no high level buffering (eg WinCE) a lot of + * In many situations where there is no high level buffering a lot of * reads might be short sequential reads, and a lot of writes may be short * sequential writes. eg. scanning/writing a jpeg file. - * In these cases, a short read/write cache can provide a huge perfomance benefit - * with dumb-as-a-rock code. - * In Linux, the page cache provides read buffering aand the short op cache provides write - * buffering. + * In these cases, a short read/write cache can provide a huge perfomance + * benefit with dumb-as-a-rock code. + * In Linux, the page cache provides read buffering and the short op cache + * provides write buffering. * * There are a limited number (~10) of cache chunks per device so that we don't * need a very intelligent search. */ -static int yaffs_obj_cache_dirty(yaffs_obj_t *obj) +static int yaffs_obj_cache_dirty(struct yaffs_obj *obj) { - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; int i; - yaffs_cache_t *cache; + struct yaffs_cache *cache; int n_caches = obj->my_dev->param.n_caches; for (i = 0; i < n_caches; i++) { cache = &dev->cache[i]; - if (cache->object == obj && - cache->dirty) + if (cache->object == obj && cache->dirty) return 1; } return 0; } - -static void yaffs_flush_file_cache(yaffs_obj_t *obj) +static void yaffs_flush_file_cache(struct yaffs_obj *obj) { - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; int lowest = -99; /* Stop compiler whining. */ int i; - yaffs_cache_t *cache; + struct yaffs_cache *cache; int chunk_written = 0; int n_caches = obj->my_dev->param.n_caches; @@ -3229,10 +3095,9 @@ static void yaffs_flush_file_cache(yaffs_obj_t *obj) chunk_written = yaffs_wr_data_obj(cache->object, - cache->chunk_id, - cache->data, - cache->n_bytes, - 1); + cache->chunk_id, + cache->data, + cache->n_bytes, 1); cache->dirty = 0; cache->object = NULL; } @@ -3242,7 +3107,9 @@ static void yaffs_flush_file_cache(yaffs_obj_t *obj) if (cache) { /* Hoosterman, disk full while writing cache out. */ T(YAFFS_TRACE_ERROR, - (TSTR("yaffs tragedy: no space during cache write" TENDSTR))); + (TSTR + ("yaffs tragedy: no space during cache write" + TENDSTR))); } } @@ -3254,9 +3121,9 @@ static void yaffs_flush_file_cache(yaffs_obj_t *obj) * */ -void yaffs_flush_whole_cache(yaffs_dev_t *dev) +void yaffs_flush_whole_cache(struct yaffs_dev *dev) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int n_caches = dev->param.n_caches; int i; @@ -3266,8 +3133,7 @@ void yaffs_flush_whole_cache(yaffs_dev_t *dev) do { obj = NULL; for (i = 0; i < n_caches && !obj; i++) { - if (dev->cache[i].object && - dev->cache[i].dirty) + if (dev->cache[i].object && dev->cache[i].dirty) obj = dev->cache[i].object; } @@ -3278,13 +3144,12 @@ void yaffs_flush_whole_cache(yaffs_dev_t *dev) } - /* Grab us a cache chunk for use. * First look for an empty one. * Then look for the least recently used non-dirty one. * Then look for the least recently used dirty one...., flush and look again. */ -static yaffs_cache_t *yaffs_grab_chunk_worker(yaffs_dev_t *dev) +static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev) { int i; @@ -3298,10 +3163,10 @@ static yaffs_cache_t *yaffs_grab_chunk_worker(yaffs_dev_t *dev) return NULL; } -static yaffs_cache_t *yaffs_grab_chunk_cache(yaffs_dev_t *dev) +static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) { - yaffs_cache_t *cache; - yaffs_obj_t *the_obj; + struct yaffs_cache *cache; + struct yaffs_obj *the_obj; int usage; int i; int pushout; @@ -3328,7 +3193,8 @@ static yaffs_cache_t *yaffs_grab_chunk_cache(yaffs_dev_t *dev) for (i = 0; i < dev->param.n_caches; i++) { if (dev->cache[i].object && !dev->cache[i].locked && - (dev->cache[i].last_use < usage || !cache)) { + (dev->cache[i].last_use < usage + || !cache)) { usage = dev->cache[i].last_use; the_obj = dev->cache[i].object; cache = &dev->cache[i]; @@ -3350,10 +3216,10 @@ static yaffs_cache_t *yaffs_grab_chunk_cache(yaffs_dev_t *dev) } /* Find a cached chunk */ -static yaffs_cache_t *yaffs_find_chunk_cache(const yaffs_obj_t *obj, - int chunk_id) +static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, + int chunk_id) { - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; int i; if (dev->param.n_caches > 0) { for (i = 0; i < dev->param.n_caches; i++) { @@ -3369,8 +3235,8 @@ static yaffs_cache_t *yaffs_find_chunk_cache(const yaffs_obj_t *obj, } /* Mark the chunk for the least recently used algorithym */ -static void yaffs_use_cache(yaffs_dev_t *dev, yaffs_cache_t *cache, - int is_write) +static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache, + int is_write) { if (dev->param.n_caches > 0) { @@ -3396,10 +3262,11 @@ static void yaffs_use_cache(yaffs_dev_t *dev, yaffs_cache_t *cache, * Do this when a whole page gets written, * ie the short cache for this page is no longer valid. */ -static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id) +static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id) { if (object->my_dev->param.n_caches > 0) { - yaffs_cache_t *cache = yaffs_find_chunk_cache(object, chunk_id); + struct yaffs_cache *cache = + yaffs_find_chunk_cache(object, chunk_id); if (cache) cache->object = NULL; @@ -3409,10 +3276,10 @@ static void yaffs_invalidate_chunk_cache(yaffs_obj_t *object, int chunk_id) /* Invalidate all the cache pages associated with this object * Do this whenever ther file is deleted or resized. */ -static void yaffs_invalidate_whole_cache(yaffs_obj_t *in) +static void yaffs_invalidate_whole_cache(struct yaffs_obj *in) { int i; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; if (dev->param.n_caches > 0) { /* Invalidate it. */ @@ -3423,7 +3290,6 @@ static void yaffs_invalidate_whole_cache(yaffs_obj_t *in) } } - /*--------------------- File read/write ------------------------ * Read and write have very similar structures. * In general the read/write has three parts to it @@ -3434,18 +3300,17 @@ static void yaffs_invalidate_whole_cache(yaffs_obj_t *in) * Curve-balls: the first chunk might also be the last chunk. */ -int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset, - int n_bytes) +int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) { int chunk; - __u32 start; + u32 start; int n_copy; int n = n_bytes; int n_done = 0; - yaffs_cache_t *cache; + struct yaffs_cache *cache; - yaffs_dev_t *dev; + struct yaffs_dev *dev; dev = in->my_dev; @@ -3469,20 +3334,21 @@ int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset, * or we're using inband tags then use the cache (if there is caching) * else bypass the cache. */ - if (cache || n_copy != dev->data_bytes_per_chunk || dev->param.inband_tags) { + if (cache || n_copy != dev->data_bytes_per_chunk + || dev->param.inband_tags) { if (dev->param.n_caches > 0) { /* If we can't find the data in the cache, then load it up. */ if (!cache) { - cache = yaffs_grab_chunk_cache(in->my_dev); + cache = + yaffs_grab_chunk_cache(in->my_dev); cache->object = in; cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; yaffs_rd_data_obj(in, chunk, - cache-> - data); + cache->data); cache->n_bytes = 0; } @@ -3490,23 +3356,20 @@ int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset, cache->locked = 1; - memcpy(buffer, &cache->data[start], n_copy); cache->locked = 0; } else { - /* Read into the local buffer then copy..*/ + /* Read into the local buffer then copy.. */ - __u8 *local_buffer = + u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); - yaffs_rd_data_obj(in, chunk, - local_buffer); + yaffs_rd_data_obj(in, chunk, local_buffer); memcpy(buffer, &local_buffer[start], n_copy); - yaffs_release_temp_buffer(dev, local_buffer, - __LINE__); + __LINE__); } } else { @@ -3526,22 +3389,22 @@ int yaffs_file_rd(yaffs_obj_t *in, __u8 *buffer, loff_t offset, return n_done; } -int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough) +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough) { int chunk; - __u32 start; + u32 start; int n_copy; int n = n_bytes; int n_done = 0; int n_writeback; int start_write = offset; int chunk_written = 0; - __u32 n_bytes_read; - __u32 chunk_start; + u32 n_bytes_read; + u32 chunk_start; - yaffs_dev_t *dev; + struct yaffs_dev *dev; dev = in->my_dev; @@ -3549,13 +3412,13 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, yaffs_addr_to_chunk(dev, offset, &chunk, &start); if (chunk * dev->data_bytes_per_chunk + start != offset || - start >= dev->data_bytes_per_chunk) { - T(YAFFS_TRACE_ERROR, ( - TSTR("AddrToChunk of offset %d gives chunk %d start %d" - TENDSTR), - (int)offset, chunk, start)); + start >= dev->data_bytes_per_chunk) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("AddrToChunk of offset %d gives chunk %d start %d" + TENDSTR), (int)offset, chunk, start)); } - chunk++; /* File pos to chunk in file offset */ + chunk++; /* File pos to chunk in file offset */ /* OK now check for the curveball where the start and end are in * the same chunk. @@ -3572,9 +3435,11 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, chunk_start = ((chunk - 1) * dev->data_bytes_per_chunk); if (chunk_start > in->variant.file_variant.file_size) - n_bytes_read = 0; /* Past end of file */ + n_bytes_read = 0; /* Past end of file */ else - n_bytes_read = in->variant.file_variant.file_size - chunk_start; + n_bytes_read = + in->variant.file_variant.file_size - + chunk_start; if (n_bytes_read > dev->data_bytes_per_chunk) n_bytes_read = dev->data_bytes_per_chunk; @@ -3583,7 +3448,8 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, (n_bytes_read > (start + n)) ? n_bytes_read : (start + n); - if (n_writeback < 0 || n_writeback > dev->data_bytes_per_chunk) + if (n_writeback < 0 + || n_writeback > dev->data_bytes_per_chunk) YBUG(); } else { @@ -3591,12 +3457,13 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, n_writeback = dev->data_bytes_per_chunk; } - if (n_copy != dev->data_bytes_per_chunk || dev->param.inband_tags) { + if (n_copy != dev->data_bytes_per_chunk + || dev->param.inband_tags) { /* An incomplete start or end chunk (or maybe both start and end chunk), * or we're using inband tags, so we want to use the cache buffers. */ if (dev->param.n_caches > 0) { - yaffs_cache_t *cache; + struct yaffs_cache *cache; /* If we can't find the data in the cache, then load the cache */ cache = yaffs_find_chunk_cache(in, chunk); @@ -3608,25 +3475,24 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, cache->dirty = 0; cache->locked = 0; yaffs_rd_data_obj(in, chunk, - cache->data); + cache->data); } else if (cache && - !cache->dirty && - !yaffs_check_alloc_available(dev, 1)) { + !cache->dirty && + !yaffs_check_alloc_available(dev, + 1)) { /* Drop the cache if it was a read cache item and * no space check has been made for it. */ - cache = NULL; + cache = NULL; } if (cache) { yaffs_use_cache(dev, cache, 1); cache->locked = 1; - memcpy(&cache->data[start], buffer, n_copy); - cache->locked = 0; cache->n_bytes = n_writeback; @@ -3635,8 +3501,8 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, yaffs_wr_data_obj (cache->object, cache->chunk_id, - cache->data, cache->n_bytes, - 1); + cache->data, + cache->n_bytes, 1); cache->dirty = 0; } @@ -3648,36 +3514,29 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, * Read into the local buffer then copy, then copy over and write back. */ - __u8 *local_buffer = + u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); - yaffs_rd_data_obj(in, chunk, - local_buffer); - - + yaffs_rd_data_obj(in, chunk, local_buffer); memcpy(&local_buffer[start], buffer, n_copy); chunk_written = yaffs_wr_data_obj(in, chunk, - local_buffer, - n_writeback, - 0); + local_buffer, + n_writeback, 0); yaffs_release_temp_buffer(dev, local_buffer, - __LINE__); + __LINE__); } } else { /* A full chunk. Write directly from the supplied buffer. */ - - chunk_written = yaffs_wr_data_obj(in, chunk, buffer, - dev->data_bytes_per_chunk, - 0); + dev->data_bytes_per_chunk, 0); /* Since we've overwritten the cached data, we better invalidate it. */ yaffs_invalidate_chunk_cache(in, chunk); @@ -3702,21 +3561,19 @@ int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, return n_done; } -int yaffs_wr_file(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough) +int yaffs_wr_file(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough) { - yaffs2_handle_hole(in,offset); - return yaffs_do_file_wr(in,buffer,offset,n_bytes,write_trhrough); + yaffs2_handle_hole(in, offset); + return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_trhrough); } - - /* ---------------------- File resizing stuff ------------------ */ -static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size) +static void yaffs_prune_chunks(struct yaffs_obj *in, int new_size) { - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; int old_size = in->variant.file_variant.file_size; int last_del = 1 + (old_size - 1) / dev->data_bytes_per_chunk; @@ -3738,12 +3595,14 @@ static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size) chunk_id = yaffs_find_del_file_chunk(in, i, NULL); if (chunk_id > 0) { if (chunk_id < - (dev->internal_start_block * dev->param.chunks_per_block) + (dev->internal_start_block * + dev->param.chunks_per_block) || chunk_id >= ((dev->internal_end_block + 1) * dev->param.chunks_per_block)) { T(YAFFS_TRACE_ALWAYS, - (TSTR("Found daft chunk_id %d for %d" TENDSTR), + (TSTR + ("Found daft chunk_id %d for %d" TENDSTR), chunk_id, i)); } else { in->n_data_chunks--; @@ -3754,12 +3613,11 @@ static void yaffs_prune_chunks(yaffs_obj_t *in, int new_size) } - -void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size) +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size) { int new_full; - __u32 new_partial; - yaffs_dev_t *dev = obj->my_dev; + u32 new_partial; + struct yaffs_dev *dev = obj->my_dev; yaffs_addr_to_chunk(dev, new_size, &new_full, &new_partial); @@ -3767,15 +3625,15 @@ void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size) if (new_partial != 0) { int last_chunk = 1 + new_full; - __u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); + u8 *local_buffer = yaffs_get_temp_buffer(dev, __LINE__); /* Got to read and rewrite the last chunk with its new size and zero pad */ yaffs_rd_data_obj(obj, last_chunk, local_buffer); memset(local_buffer + new_partial, 0, - dev->data_bytes_per_chunk - new_partial); + dev->data_bytes_per_chunk - new_partial); yaffs_wr_data_obj(obj, last_chunk, local_buffer, - new_partial, 1); + new_partial, 1); yaffs_release_temp_buffer(dev, local_buffer, __LINE__); } @@ -3785,30 +3643,29 @@ void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size) yaffs_prune_tree(dev, &obj->variant.file_variant); } - -int yaffs_resize_file(yaffs_obj_t *in, loff_t new_size) +int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) { - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; int old_size = in->variant.file_variant.file_size; yaffs_flush_file_cache(in); yaffs_invalidate_whole_cache(in); - yaffs_check_gc(dev,0); + yaffs_check_gc(dev, 0); if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; if (new_size == old_size) return YAFFS_OK; - - if(new_size > old_size){ - yaffs2_handle_hole(in,new_size); + + if (new_size > old_size) { + yaffs2_handle_hole(in, new_size); in->variant.file_variant.file_size = new_size; } else { - /* new_size < old_size */ + /* new_size < old_size */ yaffs_resize_file_down(in, new_size); - } + } /* Write a new object header to reflect the resize. * show we've shrunk the file, if need be @@ -3821,50 +3678,22 @@ int yaffs_resize_file(yaffs_obj_t *in, loff_t new_size) in->parent->obj_id != YAFFS_OBJECTID_DELETED) yaffs_update_oh(in, NULL, 0, 0, 0, NULL); - return YAFFS_OK; } -loff_t yaffs_get_file_size(yaffs_obj_t *obj) -{ - YCHAR *alias = NULL; - obj = yaffs_get_equivalent_obj(obj); - - switch (obj->variant_type) { - case YAFFS_OBJECT_TYPE_FILE: - return obj->variant.file_variant.file_size; - case YAFFS_OBJECT_TYPE_SYMLINK: - alias = obj->variant.symlink_variant.alias; - if(!alias) - return 0; - return yaffs_strnlen(alias,YAFFS_MAX_ALIAS_LENGTH); - default: - return 0; - } -} - - - -int yaffs_flush_file(yaffs_obj_t *in, int update_time, int data_sync) +int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync) { int ret_val; if (in->dirty) { yaffs_flush_file_cache(in); - if(data_sync) /* Only sync data */ - ret_val=YAFFS_OK; + if (data_sync) /* Only sync data */ + ret_val = YAFFS_OK; else { - if (update_time) { -#ifdef CONFIG_YAFFS_WINCE - yfsd_win_file_time_now(in->win_mtime); -#else - - in->yst_mtime = Y_CURRENT_TIME; - -#endif - } + if (update_time) + yaffs_load_current_time(in, 0, 0); ret_val = (yaffs_update_oh(in, NULL, 0, 0, 0, NULL) >= - 0) ? YAFFS_OK : YAFFS_FAIL; + 0) ? YAFFS_OK : YAFFS_FAIL; } } else { ret_val = YAFFS_OK; @@ -3874,7 +3703,7 @@ int yaffs_flush_file(yaffs_obj_t *in, int update_time, int data_sync) } -static int yaffs_generic_obj_del(yaffs_obj_t *in) +static int yaffs_generic_obj_del(struct yaffs_obj *in) { /* First off, invalidate the file's data in the cache, without flushing. */ @@ -3882,7 +3711,8 @@ static int yaffs_generic_obj_del(yaffs_obj_t *in) if (in->my_dev->param.is_yaffs2 && (in->parent != in->my_dev->del_dir)) { /* Move to the unlinked directory so we have a record that it was deleted. */ - yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, 0); + yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, + 0); } @@ -3899,12 +3729,12 @@ static int yaffs_generic_obj_del(yaffs_obj_t *in) * and the inode associated with the file. * It does not delete the links associated with the file. */ -static int yaffs_unlink_file_if_needed(yaffs_obj_t *in) +static int yaffs_unlink_file_if_needed(struct yaffs_obj *in) { int ret_val; int del_now = 0; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; if (!in->my_inode) del_now = 1; @@ -3912,7 +3742,7 @@ static int yaffs_unlink_file_if_needed(yaffs_obj_t *in) if (del_now) { ret_val = yaffs_change_obj_name(in, in->my_dev->del_dir, - _Y("deleted"), 0, 0); + _Y("deleted"), 0, 0); T(YAFFS_TRACE_TRACING, (TSTR("yaffs: immediate deletion of file %d" TENDSTR), in->obj_id)); @@ -3924,18 +3754,17 @@ static int yaffs_unlink_file_if_needed(yaffs_obj_t *in) } else { ret_val = yaffs_change_obj_name(in, in->my_dev->unlinked_dir, - _Y("unlinked"), 0, 0); + _Y("unlinked"), 0, 0); } - return ret_val; } -int yaffs_del_file(yaffs_obj_t *in) +int yaffs_del_file(struct yaffs_obj *in) { int ret_val = YAFFS_OK; - int deleted; /* Need to cache value on stack if in is freed */ - yaffs_dev_t *dev = in->my_dev; + int deleted; /* Need to cache value on stack if in is freed */ + struct yaffs_dev *dev = in->my_dev; if (dev->param.disable_soft_del || dev->param.is_yaffs2) yaffs_resize_file(in, 0); @@ -3966,13 +3795,13 @@ int yaffs_del_file(yaffs_obj_t *in) } } -static int yaffs_is_non_empty_dir(yaffs_obj_t *obj) +static int yaffs_is_non_empty_dir(struct yaffs_obj *obj) { return (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && - !(ylist_empty(&obj->variant.dir_variant.children)); + !(list_empty(&obj->variant.dir_variant.children)); } -static int yaffs_del_dir(yaffs_obj_t *obj) +static int yaffs_del_dir(struct yaffs_obj *obj) { /* First check that the directory is empty. */ if (yaffs_is_non_empty_dir(obj)) @@ -3981,35 +3810,38 @@ static int yaffs_del_dir(yaffs_obj_t *obj) return yaffs_generic_obj_del(obj); } -static int yaffs_del_symlink(yaffs_obj_t *in) +static int yaffs_del_symlink(struct yaffs_obj *in) { - if(in->variant.symlink_variant.alias) + if (in->variant.symlink_variant.alias) YFREE(in->variant.symlink_variant.alias); - in->variant.symlink_variant.alias=NULL; + in->variant.symlink_variant.alias = NULL; return yaffs_generic_obj_del(in); } -static int yaffs_del_link(yaffs_obj_t *in) +static int yaffs_del_link(struct yaffs_obj *in) { /* remove this hardlink from the list assocaited with the equivalent * object */ - ylist_del_init(&in->hard_links); + list_del_init(&in->hard_links); return yaffs_generic_obj_del(in); } -int yaffs_del_obj(yaffs_obj_t *obj) +int yaffs_del_obj(struct yaffs_obj *obj) { -int ret_val = -1; + int ret_val = -1; switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: ret_val = yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - if(!ylist_empty(&obj->variant.dir_variant.dirty)){ - T(YAFFS_TRACE_BACKGROUND, (TSTR("Remove object %d from dirty directories" TENDSTR),obj->obj_id)); - ylist_del_init(&obj->variant.dir_variant.dirty); + if (!list_empty(&obj->variant.dir_variant.dirty)) { + T(YAFFS_TRACE_BACKGROUND, + (TSTR + ("Remove object %d from dirty directories" TENDSTR), + obj->obj_id)); + list_del_init(&obj->variant.dir_variant.dirty); } return yaffs_del_dir(obj); break; @@ -4030,7 +3862,7 @@ int ret_val = -1; return ret_val; } -static int yaffs_unlink_worker(yaffs_obj_t *obj) +static int yaffs_unlink_worker(struct yaffs_obj *obj) { int del_now = 0; @@ -4038,12 +3870,12 @@ static int yaffs_unlink_worker(yaffs_obj_t *obj) if (!obj->my_inode) del_now = 1; - if(obj) + if (obj) yaffs_update_parent(obj->parent); if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { return yaffs_del_link(obj); - } else if (!ylist_empty(&obj->hard_links)) { + } else if (!list_empty(&obj->hard_links)) { /* Curve ball: We're unlinking an object that has a hardlink. * * This problem arises because we are not strictly following @@ -4058,21 +3890,22 @@ static int yaffs_unlink_worker(yaffs_obj_t *obj) * - Delete the hardlink */ - yaffs_obj_t *hl; - yaffs_obj_t *parent; + struct yaffs_obj *hl; + struct yaffs_obj *parent; int ret_val; YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; - hl = ylist_entry(obj->hard_links.next, yaffs_obj_t, hard_links); + hl = list_entry(obj->hard_links.next, struct yaffs_obj, + hard_links); yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1); parent = hl->parent; - ylist_del_init(&hl->hard_links); + list_del_init(&hl->hard_links); - yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); + yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); - ret_val = yaffs_change_obj_name(obj,parent, name, 0, 0); + ret_val = yaffs_change_obj_name(obj, parent, name, 0, 0); if (ret_val == YAFFS_OK) ret_val = yaffs_generic_obj_del(hl); @@ -4085,7 +3918,7 @@ static int yaffs_unlink_worker(yaffs_obj_t *obj) return yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - ylist_del_init(&obj->variant.dir_variant.dirty); + list_del_init(&obj->variant.dir_variant.dirty); return yaffs_del_dir(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: @@ -4099,15 +3932,14 @@ static int yaffs_unlink_worker(yaffs_obj_t *obj) default: return YAFFS_FAIL; } - } else if(yaffs_is_non_empty_dir(obj)) + } else if (yaffs_is_non_empty_dir(obj)) return YAFFS_FAIL; else return yaffs_change_obj_name(obj, obj->my_dev->unlinked_dir, - _Y("unlinked"), 0, 0); + _Y("unlinked"), 0, 0); } - -static int yaffs_unlink_obj(yaffs_obj_t *obj) +static int yaffs_unlink_obj(struct yaffs_obj *obj) { if (obj && obj->unlink_allowed) @@ -4116,9 +3948,10 @@ static int yaffs_unlink_obj(yaffs_obj_t *obj) return YAFFS_FAIL; } -int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name) + +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; obj = yaffs_find_by_name(dir, name); return yaffs_unlink_obj(obj); @@ -4126,10 +3959,10 @@ int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name) /*----------------------- Initialisation Scanning ---------------------- */ -void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, - int backward_scanning) +void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, + int backward_scanning) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; if (!backward_scanning) { /* Handle YAFFS1 forward scanning case @@ -4141,7 +3974,7 @@ void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, * If the shadowed object exists then ignore. */ obj = yaffs_find_by_number(dev, obj_id); - if(obj) + if (obj) return; } @@ -4149,8 +3982,7 @@ void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, * We put it in unlinked dir to be cleaned up after the scanning */ obj = - yaffs_find_or_create_by_number(dev, obj_id, - YAFFS_OBJECT_TYPE_FILE); + yaffs_find_or_create_by_number(dev, obj_id, YAFFS_OBJECT_TYPE_FILE); if (!obj) return; obj->is_shadowed = 1; @@ -4160,61 +3992,58 @@ void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, } - -void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list) +void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list) { - yaffs_obj_t *hl; - yaffs_obj_t *in; + struct yaffs_obj *hl; + struct yaffs_obj *in; while (hard_list) { hl = hard_list; - hard_list = (yaffs_obj_t *) (hard_list->hard_links.next); + hard_list = (struct yaffs_obj *)(hard_list->hard_links.next); in = yaffs_find_by_number(dev, - hl->variant.hardlink_variant. - equiv_id); + hl->variant. + hardlink_variant.equiv_id); if (in) { /* Add the hardlink pointers */ hl->variant.hardlink_variant.equiv_obj = in; - ylist_add(&hl->hard_links, &in->hard_links); + list_add(&hl->hard_links, &in->hard_links); } else { /* Todo Need to report/handle this better. * Got a problem... hardlink to a non-existant object */ hl->variant.hardlink_variant.equiv_obj = NULL; - YINIT_LIST_HEAD(&hl->hard_links); + INIT_LIST_HEAD(&hl->hard_links); } } } - -static void yaffs_strip_deleted_objs(yaffs_dev_t *dev) +static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) { /* - * Sort out state of unlinked and deleted objects after scanning. - */ - struct ylist_head *i; - struct ylist_head *n; - yaffs_obj_t *l; + * Sort out state of unlinked and deleted objects after scanning. + */ + struct list_head *i; + struct list_head *n; + struct yaffs_obj *l; if (dev->read_only) return; /* Soft delete all the unlinked files */ - ylist_for_each_safe(i, n, - &dev->unlinked_dir->variant.dir_variant.children) { + list_for_each_safe(i, n, + &dev->unlinked_dir->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_obj_t, siblings); + l = list_entry(i, struct yaffs_obj, siblings); yaffs_del_obj(l); } } - ylist_for_each_safe(i, n, - &dev->del_dir->variant.dir_variant.children) { + list_for_each_safe(i, n, &dev->del_dir->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_obj_t, siblings); + l = list_entry(i, struct yaffs_obj, siblings); yaffs_del_obj(l); } } @@ -4237,21 +4066,20 @@ static void yaffs_strip_deleted_objs(yaffs_dev_t *dev) * This fixes the problem where directories might have inadvertently been deleted * leaving the object "hanging" without being rooted in the directory tree. */ - -static int yaffs_has_null_parent(yaffs_dev_t *dev, yaffs_obj_t *obj) + +static int yaffs_has_null_parent(struct yaffs_dev *dev, struct yaffs_obj *obj) { return (obj == dev->del_dir || - obj == dev->unlinked_dir|| - obj == dev->root_dir); + obj == dev->unlinked_dir || obj == dev->root_dir); } -static void yaffs_fix_hanging_objs(yaffs_dev_t *dev) +static void yaffs_fix_hanging_objs(struct yaffs_dev *dev) { - yaffs_obj_t *obj; - yaffs_obj_t *parent; + struct yaffs_obj *obj; + struct yaffs_obj *parent; int i; - struct ylist_head *lh; - struct ylist_head *n; + struct list_head *lh; + struct list_head *n; int depth_limit; int hanging; @@ -4263,91 +4091,95 @@ static void yaffs_fix_hanging_objs(yaffs_dev_t *dev) * Make sure it is rooted. */ - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each_safe(lh, n, &dev->obj_bucket[i].list) { + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each_safe(lh, n, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_obj_t, hash_link); - parent= obj->parent; - - if(yaffs_has_null_parent(dev,obj)){ + obj = + list_entry(lh, struct yaffs_obj, hash_link); + parent = obj->parent; + + if (yaffs_has_null_parent(dev, obj)) { /* These directories are not hanging */ hanging = 0; - } - else if(!parent || parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) hanging = 1; - else if(yaffs_has_null_parent(dev,parent)) + else if (yaffs_has_null_parent(dev, parent)) hanging = 0; else { /* * Need to follow the parent chain to see if it is hanging. */ hanging = 0; - depth_limit=100; + depth_limit = 100; - while(parent != dev->root_dir && - parent->parent && - parent->parent->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - depth_limit > 0){ + while (parent != dev->root_dir && + parent->parent && + parent->parent->variant_type == + YAFFS_OBJECT_TYPE_DIRECTORY + && depth_limit > 0) { parent = parent->parent; depth_limit--; } - if(parent != dev->root_dir) + if (parent != dev->root_dir) hanging = 1; } - if(hanging){ + if (hanging) { T(YAFFS_TRACE_SCAN, - (TSTR("Hanging object %d moved to lost and found" TENDSTR), - obj->obj_id)); - yaffs_add_obj_to_dir(dev->lost_n_found,obj); + (TSTR + ("Hanging object %d moved to lost and found" + TENDSTR), obj->obj_id)); + yaffs_add_obj_to_dir(dev->lost_n_found, + obj); } } } } } - /* * Delete directory contents for cleaning up lost and found. */ -static void yaffs_del_dir_contents(yaffs_obj_t *dir) +static void yaffs_del_dir_contents(struct yaffs_obj *dir) { - yaffs_obj_t *obj; - struct ylist_head *lh; - struct ylist_head *n; + struct yaffs_obj *obj; + struct list_head *lh; + struct list_head *n; - if(dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) YBUG(); - - ylist_for_each_safe(lh, n, &dir->variant.dir_variant.children) { + + list_for_each_safe(lh, n, &dir->variant.dir_variant.children) { if (lh) { - obj = ylist_entry(lh, yaffs_obj_t, siblings); - if(obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) + obj = list_entry(lh, struct yaffs_obj, siblings); + if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) yaffs_del_dir_contents(obj); T(YAFFS_TRACE_SCAN, - (TSTR("Deleting lost_found object %d" TENDSTR), - obj->obj_id)); + (TSTR("Deleting lost_found object %d" TENDSTR), + obj->obj_id)); /* Need to use UnlinkObject since Delete would not handle * hardlinked objects correctly. */ - yaffs_unlink_obj(obj); + yaffs_unlink_obj(obj); } } - + } -static void yaffs_empty_l_n_f(yaffs_dev_t *dev) +static void yaffs_empty_l_n_f(struct yaffs_dev *dev) { yaffs_del_dir_contents(dev->lost_n_found); } -static void yaffs_check_obj_details_loaded(yaffs_obj_t *in) +static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) { - __u8 *chunk_data; - yaffs_obj_header *oh; - yaffs_dev_t *dev; - yaffs_ext_tags tags; + u8 *chunk_data; + struct yaffs_obj_hdr *oh; + struct yaffs_dev *dev; + struct yaffs_ext_tags tags; int result; int alloc_failed = 0; @@ -4356,43 +4188,24 @@ static void yaffs_check_obj_details_loaded(yaffs_obj_t *in) dev = in->my_dev; -#if 0 - T(YAFFS_TRACE_SCAN, (TSTR("details for object %d %s loaded" TENDSTR), - in->obj_id, - in->lazy_loaded ? "not yet" : "already")); -#endif - if (in->lazy_loaded && in->hdr_chunk > 0) { in->lazy_loaded = 0; chunk_data = yaffs_get_temp_buffer(dev, __LINE__); - result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data, &tags); - oh = (yaffs_obj_header *) chunk_data; + result = + yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, chunk_data, + &tags); + oh = (struct yaffs_obj_hdr *)chunk_data; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; - -#endif + yaffs_load_attribs(in, oh); yaffs_set_obj_name_from_oh(in, oh); if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { in->variant.symlink_variant.alias = - yaffs_clone_str(oh->alias); + yaffs_clone_str(oh->alias); if (!in->variant.symlink_variant.alias) - alloc_failed = 1; /* Not returned to caller */ + alloc_failed = 1; /* Not returned to caller */ } yaffs_release_temp_buffer(dev, chunk_data, __LINE__); @@ -4416,58 +4229,58 @@ static void yaffs_check_obj_details_loaded(yaffs_obj_t *in) * If the directory updating is defered then yaffs_update_dirty_dirs must be * called periodically. */ - -static void yaffs_update_parent(yaffs_obj_t *obj) + +static void yaffs_update_parent(struct yaffs_obj *obj) { - yaffs_dev_t *dev; - if(!obj) + struct yaffs_dev *dev; + if (!obj) return; -#ifndef CONFIG_YAFFS_WINCE - dev = obj->my_dev; obj->dirty = 1; - obj->yst_mtime = obj->yst_ctime = Y_CURRENT_TIME; - if(dev->param.defered_dir_update){ - struct ylist_head *link = &obj->variant.dir_variant.dirty; - - if(ylist_empty(link)){ - ylist_add(link,&dev->dirty_dirs); - T(YAFFS_TRACE_BACKGROUND, (TSTR("Added object %d to dirty directories" TENDSTR),obj->obj_id)); + yaffs_load_current_time(obj, 0, 1); + if (dev->param.defered_dir_update) { + struct list_head *link = &obj->variant.dir_variant.dirty; + + if (list_empty(link)) { + list_add(link, &dev->dirty_dirs); + T(YAFFS_TRACE_BACKGROUND, + (TSTR("Added object %d to dirty directories" TENDSTR), + obj->obj_id)); } } else yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); -#endif } -void yaffs_update_dirty_dirs(yaffs_dev_t *dev) +void yaffs_update_dirty_dirs(struct yaffs_dev *dev) { - struct ylist_head *link; - yaffs_obj_t *obj; - yaffs_dir_s *d_s; - yaffs_obj_variant *o_v; + struct list_head *link; + struct yaffs_obj *obj; + struct yaffs_dir_var *d_s; + union yaffs_obj_var *o_v; T(YAFFS_TRACE_BACKGROUND, (TSTR("Update dirty directories" TENDSTR))); - while(!ylist_empty(&dev->dirty_dirs)){ + while (!list_empty(&dev->dirty_dirs)) { link = dev->dirty_dirs.next; - ylist_del_init(link); - - d_s=ylist_entry(link,yaffs_dir_s,dirty); - o_v = ylist_entry(d_s,yaffs_obj_variant,dir_variant); - obj = ylist_entry(o_v,yaffs_obj_t,variant); + list_del_init(link); + + d_s = list_entry(link, struct yaffs_dir_var, dirty); + o_v = list_entry(d_s, union yaffs_obj_var, dir_variant); + obj = list_entry(o_v, struct yaffs_obj, variant); - T(YAFFS_TRACE_BACKGROUND, (TSTR("Update directory %d" TENDSTR), obj->obj_id)); + T(YAFFS_TRACE_BACKGROUND, + (TSTR("Update directory %d" TENDSTR), obj->obj_id)); - if(obj->dirty) + if (obj->dirty) yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } } -static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj) +static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj) { - yaffs_dev_t *dev = obj->my_dev; - yaffs_obj_t *parent; + struct yaffs_dev *dev = obj->my_dev; + struct yaffs_obj *parent; yaffs_verify_obj_in_dir(obj); parent = obj->parent; @@ -4477,15 +4290,13 @@ static void yaffs_remove_obj_from_dir(yaffs_obj_t *obj) if (dev && dev->param.remove_obj_fn) dev->param.remove_obj_fn(obj); - - ylist_del_init(&obj->siblings); + list_del_init(&obj->siblings); obj->parent = NULL; - + yaffs_verify_dir(parent); } -void yaffs_add_obj_to_dir(yaffs_obj_t *directory, - yaffs_obj_t *obj) +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj) { if (!directory) { T(YAFFS_TRACE_ALWAYS, @@ -4508,18 +4319,16 @@ void yaffs_add_obj_to_dir(yaffs_obj_t *directory, YBUG(); } - yaffs_verify_dir(directory); yaffs_remove_obj_from_dir(obj); - /* Now add it */ - ylist_add(&obj->siblings, &directory->variant.dir_variant.children); + list_add(&obj->siblings, &directory->variant.dir_variant.children); obj->parent = directory; if (directory == obj->my_dev->unlinked_dir - || directory == obj->my_dev->del_dir) { + || directory == obj->my_dev->del_dir) { obj->unlinked = 1; obj->my_dev->n_unlinked_files++; obj->rename_allowed = 0; @@ -4529,15 +4338,15 @@ void yaffs_add_obj_to_dir(yaffs_obj_t *directory, yaffs_verify_obj_in_dir(obj); } -yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory, - const YCHAR *name) +struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, + const YCHAR * name) { int sum; - struct ylist_head *i; + struct list_head *i; YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1]; - yaffs_obj_t *l; + struct yaffs_obj *l; if (!name) return NULL; @@ -4552,16 +4361,15 @@ yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory, } if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); + (TSTR("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); YBUG(); } sum = yaffs_calc_name_sum(name); - ylist_for_each(i, &directory->variant.dir_variant.children) { + list_for_each(i, &directory->variant.dir_variant.children) { if (i) { - l = ylist_entry(i, yaffs_obj_t, siblings); + l = list_entry(i, struct yaffs_obj, siblings); if (l->parent != directory) YBUG(); @@ -4570,15 +4378,18 @@ yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory, /* Special case for lost-n-found */ if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { - if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) + if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == + 0) return l; - } else if (yaffs_sum_cmp(l->sum, sum) || l->hdr_chunk <= 0) { + } else if (yaffs_sum_cmp(l->sum, sum) + || l->hdr_chunk <= 0) { /* LostnFound chunk called Objxxx * Do a real check */ yaffs_get_obj_name(l, buffer, - YAFFS_MAX_NAME_LENGTH + 1); - if (yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH) == 0) + YAFFS_MAX_NAME_LENGTH + 1); + if (yaffs_strncmp + (name, buffer, YAFFS_MAX_NAME_LENGTH) == 0) return l; } } @@ -4587,48 +4398,11 @@ yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *directory, return NULL; } - -#if 0 -int yaffs_ApplyToDirectoryChildren(yaffs_obj_t *the_dir, - int (*fn) (yaffs_obj_t *)) -{ - struct ylist_head *i; - yaffs_obj_t *l; - - if (!the_dir) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_find_by_name: null pointer directory" - TENDSTR))); - YBUG(); - return YAFFS_FAIL; - } - if (the_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_find_by_name: non-directory" TENDSTR))); - YBUG(); - return YAFFS_FAIL; - } - - ylist_for_each(i, &the_dir->variant.dir_variant.children) { - if (i) { - l = ylist_entry(i, yaffs_obj_t, siblings); - if (l && !fn(l)) - return YAFFS_FAIL; - } - } - - return YAFFS_OK; - -} -#endif - /* GetEquivalentObject dereferences any hard links to get to the * actual object. */ -yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj) +struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj) { if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { /* We want the object id of the equivalent object, not this one */ @@ -4657,167 +4431,170 @@ yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj) * starting at oh->name[1]. */ -static void yaffs_fix_null_name(yaffs_obj_t * obj,YCHAR * name, int buffer_size) +static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR * name, + int buffer_size) { /* Create an object name if we could not find one. */ - if(yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH) == 0){ + if (yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) { YCHAR local_name[20]; YCHAR num_string[20]; YCHAR *x = &num_string[19]; unsigned v = obj->obj_id; num_string[19] = 0; - while(v>0){ + while (v > 0) { x--; *x = '0' + (v % 10); v /= 10; } /* make up a name */ yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX); - yaffs_strcat(local_name,x); + yaffs_strcat(local_name, x); yaffs_strncpy(name, local_name, buffer_size - 1); } } -static void yaffs_load_name_from_oh(yaffs_dev_t *dev,YCHAR *name, const YCHAR *oh_name, int buff_size) +static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR * name, + const YCHAR * oh_name, int buff_size) { #ifdef CONFIG_YAFFS_AUTO_UNICODE - if(dev->param.auto_unicode){ - if(*oh_name){ + if (dev->param.auto_unicode) { + if (*oh_name) { /* It is an ASCII name, so do an ASCII to unicode conversion */ const char *ascii_oh_name = (const char *)oh_name; int n = buff_size - 1; - while(n > 0 && *ascii_oh_name){ + while (n > 0 && *ascii_oh_name) { *name = *ascii_oh_name; name++; ascii_oh_name++; n--; } - } else - yaffs_strncpy(name,oh_name+1, buff_size -1); + } else + yaffs_strncpy(name, oh_name + 1, buff_size - 1); } else #endif yaffs_strncpy(name, oh_name, buff_size - 1); } - -static void yaffs_load_oh_from_name(yaffs_dev_t *dev, YCHAR *oh_name, const YCHAR *name) +static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR * oh_name, + const YCHAR * name) { #ifdef CONFIG_YAFFS_AUTO_UNICODE int is_ascii; YCHAR *w; - if(dev->param.auto_unicode){ + if (dev->param.auto_unicode) { is_ascii = 1; w = name; - + /* Figure out if the name will fit in ascii character set */ - while(is_ascii && *w){ - if((*w) & 0xff00) + while (is_ascii && *w) { + if ((*w) & 0xff00) is_ascii = 0; w++; } - if(is_ascii){ + if (is_ascii) { /* It is an ASCII name, so do a unicode to ascii conversion */ char *ascii_oh_name = (char *)oh_name; - int n = YAFFS_MAX_NAME_LENGTH - 1; - while(n > 0 && *name){ - *ascii_oh_name= *name; + int n = YAFFS_MAX_NAME_LENGTH - 1; + while (n > 0 && *name) { + *ascii_oh_name = *name; name++; ascii_oh_name++; n--; } - } else{ + } else { /* It is a unicode name, so save starting at the second YCHAR */ *oh_name = 0; - yaffs_strncpy(oh_name+1,name, YAFFS_MAX_NAME_LENGTH -2); + yaffs_strncpy(oh_name + 1, name, + YAFFS_MAX_NAME_LENGTH - 2); } - } - else + } else #endif - yaffs_strncpy(oh_name,name, YAFFS_MAX_NAME_LENGTH - 1); + yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1); } -int yaffs_get_obj_name(yaffs_obj_t * obj, YCHAR * name, int buffer_size) +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size) { memset(name, 0, buffer_size * sizeof(YCHAR)); - + yaffs_check_obj_details_loaded(obj); if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1); - } + } #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM else if (obj->short_name[0]) { yaffs_strcpy(name, obj->short_name); } #endif - else if(obj->hdr_chunk > 0) { + else if (obj->hdr_chunk > 0) { int result; - __u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__); + u8 *buffer = yaffs_get_temp_buffer(obj->my_dev, __LINE__); - yaffs_obj_header *oh = (yaffs_obj_header *) buffer; + struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)buffer; memset(buffer, 0, obj->my_dev->data_bytes_per_chunk); if (obj->hdr_chunk > 0) { result = yaffs_rd_chunk_tags_nand(obj->my_dev, - obj->hdr_chunk, buffer, - NULL); + obj->hdr_chunk, + buffer, NULL); } - yaffs_load_name_from_oh(obj->my_dev,name,oh->name,buffer_size); + yaffs_load_name_from_oh(obj->my_dev, name, oh->name, + buffer_size); yaffs_release_temp_buffer(obj->my_dev, buffer, __LINE__); } - yaffs_fix_null_name(obj,name,buffer_size); + yaffs_fix_null_name(obj, name, buffer_size); - return yaffs_strnlen(name,YAFFS_MAX_NAME_LENGTH); + return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH); } - -int yaffs_get_obj_length(yaffs_obj_t *obj) +int yaffs_get_obj_length(struct yaffs_obj *obj) { /* Dereference any hard linking */ obj = yaffs_get_equivalent_obj(obj); if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) return obj->variant.file_variant.file_size; - if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK){ - if(!obj->variant.symlink_variant.alias) + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + if (!obj->variant.symlink_variant.alias) return 0; - return yaffs_strnlen(obj->variant.symlink_variant.alias,YAFFS_MAX_ALIAS_LENGTH); + return yaffs_strnlen(obj->variant.symlink_variant.alias, + YAFFS_MAX_ALIAS_LENGTH); } else { /* Only a directory should drop through to here */ return obj->my_dev->data_bytes_per_chunk; } } -int yaffs_get_obj_link_count(yaffs_obj_t *obj) +int yaffs_get_obj_link_count(struct yaffs_obj *obj) { int count = 0; - struct ylist_head *i; + struct list_head *i; if (!obj->unlinked) - count++; /* the object itself */ + count++; /* the object itself */ - ylist_for_each(i, &obj->hard_links) - count++; /* add the hard links; */ + list_for_each(i, &obj->hard_links) + count++; /* add the hard links; */ return count; } -int yaffs_get_obj_inode(yaffs_obj_t *obj) +int yaffs_get_obj_inode(struct yaffs_obj *obj) { obj = yaffs_get_equivalent_obj(obj); return obj->obj_id; } -unsigned yaffs_get_obj_type(yaffs_obj_t *obj) +unsigned yaffs_get_obj_type(struct yaffs_obj *obj) { obj = yaffs_get_equivalent_obj(obj); @@ -4849,7 +4626,7 @@ unsigned yaffs_get_obj_type(yaffs_obj_t *obj) } } -YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj) +YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj) { obj = yaffs_get_equivalent_obj(obj); if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) @@ -4858,95 +4635,43 @@ YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj) return yaffs_clone_str(_Y("")); } -#ifndef CONFIG_YAFFS_WINCE - -int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr) -{ - unsigned int valid = attr->ia_valid; - - if (valid & ATTR_MODE) - obj->yst_mode = attr->ia_mode; - if (valid & ATTR_UID) - obj->yst_uid = attr->ia_uid; - if (valid & ATTR_GID) - obj->yst_gid = attr->ia_gid; - - if (valid & ATTR_ATIME) - obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime); - if (valid & ATTR_CTIME) - obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime); - if (valid & ATTR_MTIME) - obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); - - if (valid & ATTR_SIZE) - yaffs_resize_file(obj, attr->ia_size); - - yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); - - return YAFFS_OK; - -} -int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr) -{ - unsigned int valid = 0; - - attr->ia_mode = obj->yst_mode; - valid |= ATTR_MODE; - attr->ia_uid = obj->yst_uid; - valid |= ATTR_UID; - attr->ia_gid = obj->yst_gid; - valid |= ATTR_GID; - - Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime; - valid |= ATTR_ATIME; - Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime; - valid |= ATTR_CTIME; - Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; - valid |= ATTR_MTIME; - - attr->ia_size = yaffs_get_file_size(obj); - valid |= ATTR_SIZE; - - attr->ia_valid = valid; - - return YAFFS_OK; -} - -#endif - - -static int yaffs_do_xattrib_mod(yaffs_obj_t *obj, int set, const YCHAR *name, const void *value, int size, int flags) +static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, + const YCHAR * name, const void *value, int size, + int flags) { - yaffs_xattr_mod xmod; + struct yaffs_xattr_mod xmod; int result; xmod.set = set; xmod.name = name; xmod.data = value; - xmod.size = size; + xmod.size = size; xmod.flags = flags; xmod.result = -ENOSPC; result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod); - if(result > 0) + if (result > 0) return xmod.result; else return -ENOSPC; } -static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_mod *xmod) +static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, + struct yaffs_xattr_mod *xmod) { int retval = 0; - int x_offs = sizeof(yaffs_obj_header); - yaffs_dev_t *dev = obj->my_dev; - int x_size = dev->data_bytes_per_chunk - sizeof(yaffs_obj_header); + int x_offs = sizeof(struct yaffs_obj_hdr); + struct yaffs_dev *dev = obj->my_dev; + int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); - char * x_buffer = buffer + x_offs; + char *x_buffer = buffer + x_offs; - if(xmod->set) - retval = nval_set(x_buffer, x_size, xmod->name, xmod->data, xmod->size, xmod->flags); + if (xmod->set) + retval = + nval_set(x_buffer, x_size, xmod->name, xmod->data, + xmod->size, xmod->flags); else retval = nval_del(x_buffer, x_size, xmod->name); @@ -4958,101 +4683,84 @@ static int yaffs_apply_xattrib_mod(yaffs_obj_t *obj, char *buffer, yaffs_xattr_m return retval; } -static int yaffs_do_xattrib_fetch(yaffs_obj_t *obj, const YCHAR *name, void *value, int size) +static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR * name, + void *value, int size) { char *buffer = NULL; int result; - yaffs_ext_tags tags; - yaffs_dev_t *dev = obj->my_dev; - int x_offs = sizeof(yaffs_obj_header); - int x_size = dev->data_bytes_per_chunk - sizeof(yaffs_obj_header); + struct yaffs_ext_tags tags; + struct yaffs_dev *dev = obj->my_dev; + int x_offs = sizeof(struct yaffs_obj_hdr); + int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); - char * x_buffer; + char *x_buffer; int retval = 0; - if(obj->hdr_chunk < 1) + if (obj->hdr_chunk < 1) return -ENODATA; /* If we know that the object has no xattribs then don't do all the * reading and parsing. */ - if(obj->xattr_known && !obj->has_xattr){ - if(name) + if (obj->xattr_known && !obj->has_xattr) { + if (name) return -ENODATA; else return 0; } - buffer = (char *) yaffs_get_temp_buffer(dev, __LINE__); - if(!buffer) + buffer = (char *)yaffs_get_temp_buffer(dev, __LINE__); + if (!buffer) return -ENOMEM; - result = yaffs_rd_chunk_tags_nand(dev,obj->hdr_chunk, (__u8 *)buffer, &tags); + result = + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, (u8 *) buffer, &tags); - if(result != YAFFS_OK) + if (result != YAFFS_OK) retval = -ENOENT; - else{ - x_buffer = buffer + x_offs; + else { + x_buffer = buffer + x_offs; - if (!obj->xattr_known){ + if (!obj->xattr_known) { obj->has_xattr = nval_hasvalues(x_buffer, x_size); obj->xattr_known = 1; } - if(name) + if (name) retval = nval_get(x_buffer, x_size, name, value, size); else - retval = nval_list(x_buffer, x_size, value,size); + retval = nval_list(x_buffer, x_size, value, size); } - yaffs_release_temp_buffer(dev,(__u8 *)buffer,__LINE__); + yaffs_release_temp_buffer(dev, (u8 *) buffer, __LINE__); return retval; } -int yaffs_set_xattrib(yaffs_obj_t *obj, const YCHAR *name, const void * value, int size, int flags) +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name, + const void *value, int size, int flags) { return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags); } -int yaffs_remove_xattrib(yaffs_obj_t *obj, const YCHAR *name) +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name) { return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0); } -int yaffs_get_xattrib(yaffs_obj_t *obj, const YCHAR *name, void *value, int size) +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value, + int size) { return yaffs_do_xattrib_fetch(obj, name, value, size); } -int yaffs_list_xattrib(yaffs_obj_t *obj, char *buffer, int size) +int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size) { - return yaffs_do_xattrib_fetch(obj, NULL, buffer,size); + return yaffs_do_xattrib_fetch(obj, NULL, buffer, size); } - - -#if 0 -int yaffs_dump_obj(yaffs_obj_t *obj) -{ - YCHAR name[257]; - - yaffs_get_obj_name(obj, name, YAFFS_MAX_NAME_LENGTH + 1); - - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d" - " chunk %d type %d size %d\n" - TENDSTR), obj->obj_id, yaffs_get_obj_inode(obj), name, - obj->dirty, obj->valid, obj->serial, obj->sum, obj->hdr_chunk, - yaffs_get_obj_type(obj), yaffs_get_obj_length(obj))); - - return YAFFS_OK; -} -#endif - /*---------------------------- Initialisation code -------------------------------------- */ -static int yaffs_cehck_dev_fns(const yaffs_dev_t *dev) +static int yaffs_check_dev_fns(const struct yaffs_dev *dev) { /* Common functions, gotta have */ @@ -5066,8 +4774,7 @@ static int yaffs_cehck_dev_fns(const yaffs_dev_t *dev) dev->param.read_chunk_tags_fn && !dev->param.write_chunk_fn && !dev->param.read_chunk_fn && - dev->param.bad_block_fn && - dev->param.query_block_fn) + dev->param.bad_block_fn && dev->param.query_block_fn) return 1; #endif @@ -5077,19 +4784,17 @@ static int yaffs_cehck_dev_fns(const yaffs_dev_t *dev) !dev->param.read_chunk_tags_fn && dev->param.write_chunk_fn && dev->param.read_chunk_fn && - !dev->param.bad_block_fn && - !dev->param.query_block_fn) + !dev->param.bad_block_fn && !dev->param.query_block_fn) return 1; - return 0; /* bad */ + return 0; /* bad */ } - -static int yaffs_create_initial_dir(yaffs_dev_t *dev) +static int yaffs_create_initial_dir(struct yaffs_dev *dev) { /* Initialise the unlinked, deleted, root and lost and found directories */ - dev->lost_n_found = dev->root_dir = NULL; + dev->lost_n_found = dev->root_dir = NULL; dev->unlinked_dir = dev->del_dir = NULL; dev->unlinked_dir = @@ -5100,12 +4805,13 @@ static int yaffs_create_initial_dir(yaffs_dev_t *dev) dev->root_dir = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT, - YAFFS_ROOT_MODE | S_IFDIR); + YAFFS_ROOT_MODE | S_IFDIR); dev->lost_n_found = yaffs_create_fake_dir(dev, YAFFS_OBJECTID_LOSTNFOUND, - YAFFS_LOSTNFOUND_MODE | S_IFDIR); + YAFFS_LOSTNFOUND_MODE | S_IFDIR); - if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir && dev->del_dir) { + if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir + && dev->del_dir) { yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found); return YAFFS_OK; } @@ -5113,13 +4819,14 @@ static int yaffs_create_initial_dir(yaffs_dev_t *dev) return YAFFS_FAIL; } -int yaffs_guts_initialise(yaffs_dev_t *dev) +int yaffs_guts_initialise(struct yaffs_dev *dev) { int init_failed = 0; unsigned x; int bits; - T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR))); + T(YAFFS_TRACE_TRACING, + (TSTR("yaffs: yaffs_guts_initialise()" TENDSTR))); /* Check stuff that must be set */ @@ -5145,18 +4852,12 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) /* Check geometry parameters. */ - if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || - (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || - (dev->param.inband_tags && !dev->param.is_yaffs2) || - dev->param.chunks_per_block < 2 || - dev->param.n_reserved_blocks < 2 || - dev->internal_start_block <= 0 || - dev->internal_end_block <= 0 || - dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) { /* otherwise it is too small */ + if ((!dev->param.inband_tags && dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 1024) || (!dev->param.is_yaffs2 && dev->param.total_bytes_per_chunk < 512) || (dev->param.inband_tags && !dev->param.is_yaffs2) || dev->param.chunks_per_block < 2 || dev->param.n_reserved_blocks < 2 || dev->internal_start_block <= 0 || dev->internal_end_block <= 0 || dev->internal_end_block <= (dev->internal_start_block + dev->param.n_reserved_blocks + 2)) { /* otherwise it is too small */ T(YAFFS_TRACE_ALWAYS, (TSTR ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d " - TENDSTR), dev->param.total_bytes_per_chunk, dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags)); + TENDSTR), dev->param.total_bytes_per_chunk, + dev->param.is_yaffs2 ? "2" : "", dev->param.inband_tags)); return YAFFS_FAIL; } @@ -5168,12 +4869,14 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) /* Sort out space for inband tags, if required */ if (dev->param.inband_tags) - dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk - sizeof(yaffs_packed_tags2_tags_only); + dev->data_bytes_per_chunk = + dev->param.total_bytes_per_chunk - + sizeof(struct yaffs_packed_tags2_tags_only); else dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk; /* Got the right mix of functions? */ - if (!yaffs_cehck_dev_fns(dev)) { + if (!yaffs_check_dev_fns(dev)) { /* Function missing */ T(YAFFS_TRACE_ALWAYS, (TSTR @@ -5182,13 +4885,6 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) return YAFFS_FAIL; } - /* This is really a compilation check. */ - if (!yaffs_check_structures()) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_check_structures failed\n" TENDSTR))); - return YAFFS_FAIL; - } - if (dev->is_mounted) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: device already mounted\n" TENDSTR))); @@ -5210,7 +4906,7 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) x >>= dev->chunk_shift; dev->chunk_div = x; /* We only use chunk mask if chunk_div is 1 */ - dev->chunk_mask = (1<chunk_shift) - 1; + dev->chunk_mask = (1 << dev->chunk_shift) - 1; /* * Calculate chunk_grp_bits. @@ -5233,7 +4929,7 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) } else dev->tnode_width = 16; - dev->tnode_mask = (1<tnode_width)-1; + dev->tnode_mask = (1 << dev->tnode_width) - 1; /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled), * so if the bitwidth of the @@ -5246,9 +4942,9 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) else dev->chunk_grp_bits = bits - dev->tnode_width; - dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0)/8; - if(dev->tnode_size < sizeof(yaffs_tnode_t)) - dev->tnode_size = sizeof(yaffs_tnode_t); + dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8; + if (dev->tnode_size < sizeof(struct yaffs_tnode)) + dev->tnode_size = sizeof(struct yaffs_tnode); dev->chunk_grp_size = 1 << dev->chunk_grp_bits; @@ -5282,9 +4978,9 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) dev->n_tags_ecc_unfixed = 0; dev->n_erase_failures = 0; dev->n_erased_blocks = 0; - dev->gc_disable= 0; - dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */ - YINIT_LIST_HEAD(&dev->dirty_dirs); + dev->gc_disable = 0; + dev->has_pending_prioritised_gc = 1; /* Assume the worst for now, will get fixed on first GC */ + INIT_LIST_HEAD(&dev->dirty_dirs); dev->oldest_dirty_seq = 0; dev->oldest_dirty_block = 0; @@ -5295,19 +4991,18 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) dev->cache = NULL; dev->gc_cleanup_list = NULL; - - if (!init_failed && - dev->param.n_caches > 0) { + if (!init_failed && dev->param.n_caches > 0) { int i; void *buf; - int cache_bytes = dev->param.n_caches * sizeof(yaffs_cache_t); + int cache_bytes = + dev->param.n_caches * sizeof(struct yaffs_cache); if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES) dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES; - dev->cache = YMALLOC(cache_bytes); + dev->cache = YMALLOC(cache_bytes); - buf = (__u8 *) dev->cache; + buf = (u8 *) dev->cache; if (dev->cache) memset(dev->cache, 0, cache_bytes); @@ -5316,7 +5011,8 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) dev->cache[i].object = NULL; dev->cache[i].last_use = 0; dev->cache[i].dirty = 0; - dev->cache[i].data = buf = YMALLOC_DMA(dev->param.total_bytes_per_chunk); + dev->cache[i].data = buf = + YMALLOC_DMA(dev->param.total_bytes_per_chunk); } if (!buf) init_failed = 1; @@ -5327,7 +5023,8 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) dev->cache_hits = 0; if (!init_failed) { - dev->gc_cleanup_list = YMALLOC(dev->param.chunks_per_block * sizeof(__u32)); + dev->gc_cleanup_list = + YMALLOC(dev->param.chunks_per_block * sizeof(u32)); if (!dev->gc_cleanup_list) init_failed = 1; } @@ -5343,14 +5040,15 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) if (!init_failed && !yaffs_create_initial_dir(dev)) init_failed = 1; - if (!init_failed) { /* Now scan the flash. */ if (dev->param.is_yaffs2) { if (yaffs2_checkpt_restore(dev)) { yaffs_check_obj_details_loaded(dev->root_dir); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: restored from checkpoint" TENDSTR))); + (TSTR + ("yaffs: restored from checkpoint" + TENDSTR))); } else { /* Clean up the mess caused by an aborted checkpoint load @@ -5373,18 +5071,19 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) yaffs_init_tnodes_and_objs(dev); - if (!init_failed && !yaffs_create_initial_dir(dev)) + if (!init_failed + && !yaffs_create_initial_dir(dev)) init_failed = 1; if (!init_failed && !yaffs2_scan_backwards(dev)) init_failed = 1; } } else if (!yaffs1_scan(dev)) - init_failed = 1; + init_failed = 1; yaffs_strip_deleted_objs(dev); yaffs_fix_hanging_objs(dev); - if(dev->param.empty_lost_n_found) + if (dev->param.empty_lost_n_found) yaffs_empty_l_n_f(dev); } @@ -5410,7 +5109,7 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) yaffs_verify_blocks(dev); /* Clean up any aborted checkpoint data */ - if(!dev->is_checkpointed && dev->blocks_in_checkpt > 0) + if (!dev->is_checkpointed && dev->blocks_in_checkpt > 0) yaffs2_checkpt_invalidate(dev); T(YAFFS_TRACE_TRACING, @@ -5419,15 +5118,14 @@ int yaffs_guts_initialise(yaffs_dev_t *dev) } -void yaffs_deinitialise(yaffs_dev_t *dev) +void yaffs_deinitialise(struct yaffs_dev *dev) { if (dev->is_mounted) { int i; yaffs_deinit_blocks(dev); yaffs_deinit_tnodes_and_objs(dev); - if (dev->param.n_caches > 0 && - dev->cache) { + if (dev->param.n_caches > 0 && dev->cache) { for (i = 0; i < dev->param.n_caches; i++) { if (dev->cache[i].data) @@ -5451,12 +5149,12 @@ void yaffs_deinitialise(yaffs_dev_t *dev) } } -int yaffs_count_free_chunks(yaffs_dev_t *dev) +int yaffs_count_free_chunks(struct yaffs_dev *dev) { - int n_free=0; + int n_free = 0; int b; - yaffs_block_info_t *blk; + struct yaffs_block_info *blk; blk = dev->block_info; for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { @@ -5478,7 +5176,7 @@ int yaffs_count_free_chunks(yaffs_dev_t *dev) return n_free; } -int yaffs_get_n_free_chunks(yaffs_dev_t *dev) +int yaffs_get_n_free_chunks(struct yaffs_dev *dev) { /* This is what we report to the outside world */ @@ -5487,12 +5185,7 @@ int yaffs_get_n_free_chunks(yaffs_dev_t *dev) int blocks_for_checkpt; int i; -#if 1 n_free = dev->n_free_chunks; -#else - n_free = yaffs_count_free_chunks(dev); -#endif - n_free += dev->n_deleted_files; /* Now count the number of dirty chunks in the cache and subtract those */ @@ -5504,7 +5197,8 @@ int yaffs_get_n_free_chunks(yaffs_dev_t *dev) n_free -= n_dirty_caches; - n_free -= ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); + n_free -= + ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); /* Now we figure out how much to reserve for the checkpoint and report that... */ blocks_for_checkpt = yaffs_calc_checkpt_blocks_required(dev); @@ -5517,28 +5211,3 @@ int yaffs_get_n_free_chunks(yaffs_dev_t *dev) return n_free; } - - -/*---------------------------------------- YAFFS test code ----------------------*/ - -#define yaffs_check_struct(structure, syze, name) \ - do { \ - if (sizeof(structure) != syze) { \ - T(YAFFS_TRACE_ALWAYS, (TSTR("%s should be %d but is %d\n" TENDSTR),\ - name, syze, (int) sizeof(structure))); \ - return YAFFS_FAIL; \ - } \ - } while (0) - -static int yaffs_check_structures(void) -{ -/* yaffs_check_struct(yaffs_tags_t,8,"yaffs_tags_t"); */ -/* yaffs_check_struct(yaffs_tags_union_t,8,"yaffs_tags_union_t"); */ -/* yaffs_check_struct(yaffs_spare,16,"yaffs_spare"); */ -/* yaffs_check_struct(yaffs_tnode_t, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_tnode_t"); */ - -#ifndef CONFIG_YAFFS_WINCE - yaffs_check_struct(yaffs_obj_header, 512, "yaffs_obj_header"); -#endif - return YAFFS_OK; -} diff --git a/yaffs_guts.h b/yaffs_guts.h index 2668b99..60770ca 100644 --- a/yaffs_guts.h +++ b/yaffs_guts.h @@ -17,8 +17,6 @@ #define __YAFFS_GUTS_H__ #include "yportenv.h" -#include "devextras.h" -#include "yaffs_list.h" #define YAFFS_OK 1 #define YAFFS_FAIL 0 @@ -53,14 +51,12 @@ #define YAFFS_MAX_CHUNK_ID 0x000FFFFF - #define YAFFS_ALLOCATION_NOBJECTS 100 #define YAFFS_ALLOCATION_NTNODES 100 #define YAFFS_ALLOCATION_NLINKS 100 #define YAFFS_NOBJECT_BUCKETS 256 - #define YAFFS_OBJECT_SPACE 0x40000 #define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE -1) @@ -87,7 +83,6 @@ #define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 #define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 - #define YAFFS_MAX_SHORT_OP_CACHES 20 #define YAFFS_N_TEMP_BUFFERS 6 @@ -112,17 +107,15 @@ #define YAFFS_SEQUENCE_BAD_BLOCK 0xFFFF0000 /* ChunkCache is used for short read/write operations.*/ -typedef struct { - struct yaffs_obj_s *object; +struct yaffs_cache { + struct yaffs_obj *object; int chunk_id; int last_use; int dirty; int n_bytes; /* Only valid if the cache is dirty */ int locked; /* Can't push out or flush while locked. */ - __u8 *data; -} yaffs_cache_t; - - + u8 *data; +}; /* Tags structures in RAM * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise @@ -130,52 +123,52 @@ typedef struct { */ #ifndef CONFIG_YAFFS_NO_YAFFS1 -typedef struct { +struct yaffs_tags { unsigned chunk_id:20; unsigned serial_number:2; unsigned n_bytes_lsb:10; unsigned obj_id:18; unsigned ecc:12; unsigned n_bytes_msb:2; -} yaffs_tags_t; +}; -typedef union { - yaffs_tags_t as_tags; - __u8 as_bytes[8]; -} yaffs_tags_union_t; +union yaffs_tags_union { + struct yaffs_tags as_tags; + u8 as_bytes[8]; +}; #endif /* Stuff used for extended tags in YAFFS2 */ -typedef enum { +enum yaffs_ecc_result { YAFFS_ECC_RESULT_UNKNOWN, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_ECC_RESULT_FIXED, YAFFS_ECC_RESULT_UNFIXED -} yaffs_ecc_result; +}; -typedef enum { +enum yaffs_obj_type { YAFFS_OBJECT_TYPE_UNKNOWN, YAFFS_OBJECT_TYPE_FILE, YAFFS_OBJECT_TYPE_SYMLINK, YAFFS_OBJECT_TYPE_DIRECTORY, YAFFS_OBJECT_TYPE_HARDLINK, YAFFS_OBJECT_TYPE_SPECIAL -} yaffs_obj_type; +}; #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL -typedef struct { +struct yaffs_ext_tags { - unsigned validity1; + unsigned validity0; unsigned chunk_used; /* Status of the chunk: used or unused */ unsigned obj_id; /* If 0 then this is not part of an object (unused) */ unsigned chunk_id; /* If 0 then this is a header, else a data chunk */ unsigned n_bytes; /* Only valid for data chunks */ /* The following stuff only has meaning when we read */ - yaffs_ecc_result ecc_result; + enum yaffs_ecc_result ecc_result; unsigned block_bad; /* YAFFS 1 stuff */ @@ -190,47 +183,47 @@ typedef struct { unsigned extra_available; /* There is extra info available if this is not zero */ unsigned extra_parent_id; /* The parent object */ unsigned extra_is_shrink; /* Is it a shrink header? */ - unsigned extra_shadows; /* Does this shadow another object? */ + unsigned extra_shadows; /* Does this shadow another object? */ - yaffs_obj_type extra_obj_type; /* What object type? */ + enum yaffs_obj_type extra_obj_type; /* What object type? */ - unsigned extra_length; /* Length if it is a file */ + unsigned extra_length; /* Length if it is a file */ unsigned extra_equiv_id; /* Equivalent object Id if it is a hard link */ - unsigned validty1; + unsigned validity1; -} yaffs_ext_tags; +}; /* Spare structure for YAFFS1 */ -typedef struct { - __u8 tb0; - __u8 tb1; - __u8 tb2; - __u8 tb3; - __u8 page_status; /* set to 0 to delete the chunk */ - __u8 block_status; - __u8 tb4; - __u8 tb5; - __u8 ecc1[3]; - __u8 tb6; - __u8 tb7; - __u8 ecc2[3]; -} yaffs_spare; +struct yaffs_spare { + u8 tb0; + u8 tb1; + u8 tb2; + u8 tb3; + u8 page_status; /* set to 0 to delete the chunk */ + u8 block_status; + u8 tb4; + u8 tb5; + u8 ecc1[3]; + u8 tb6; + u8 tb7; + u8 ecc2[3]; +}; /*Special structure for passing through to mtd */ struct yaffs_nand_spare { - yaffs_spare spare; + struct yaffs_spare spare; int eccres1; int eccres2; }; /* Block data in RAM */ -typedef enum { +enum yaffs_block_state { YAFFS_BLOCK_STATE_UNKNOWN = 0, YAFFS_BLOCK_STATE_SCANNING, - /* Being scanned */ + /* Being scanned */ YAFFS_BLOCK_STATE_NEEDS_SCANNING, /* The block might have something on it (ie it is allocating or full, perhaps empty) @@ -248,13 +241,13 @@ typedef enum { * At least one page holds valid data. * This is the one currently being used for page * allocation. Should never be more than one of these. - * If a block is only partially allocated at mount it is treated as full. + * If a block is only partially allocated at mount it is treated as full. */ YAFFS_BLOCK_STATE_FULL, /* All the pages in this block have been allocated. - * If a block was only partially allocated when mounted we treat - * it as fully allocated. + * If a block was only partially allocated when mounted we treat + * it as fully allocated. */ YAFFS_BLOCK_STATE_DIRTY, @@ -269,54 +262,49 @@ typedef enum { /* This block is being garbage collected */ YAFFS_BLOCK_STATE_DEAD - /* This block has failed and is not in use */ -} yaffs_block_state_t; + /* This block has failed and is not in use */ +}; #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) - -typedef struct { +struct yaffs_block_info { int soft_del_pages:10; /* number of soft deleted pages */ int pages_in_use:10; /* number of pages in use */ unsigned block_state:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ - __u32 needs_retiring:1; /* Data has failed on this block, need to get valid data off */ - /* and retire the block. */ - __u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */ - __u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block. + u32 needs_retiring:1; /* Data has failed on this block, need to get valid data off */ + /* and retire the block. */ + u32 skip_erased_check:1; /* If this is set we can skip the erased check on this block */ + u32 gc_prioritise:1; /* An ECC check or blank check has failed on this block. It should be prioritised for GC */ - __u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ + u32 chunk_error_strikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ #ifdef CONFIG_YAFFS_YAFFS2 - __u32 has_shrink_hdr:1; /* This block has at least one shrink object header */ - __u32 seq_number; /* block sequence number for yaffs2 */ + u32 has_shrink_hdr:1; /* This block has at least one shrink object header */ + u32 seq_number; /* block sequence number for yaffs2 */ #endif -} yaffs_block_info_t; +}; /* -------------------------- Object structure -------------------------------*/ /* This is the object structure as stored on NAND */ -typedef struct { - yaffs_obj_type type; +struct yaffs_obj_hdr { + enum yaffs_obj_type type; /* Apply to everything */ int parent_obj_id; - __u16 sum_no_longer_used; /* checksum of name. No longer used */ + u16 sum_no_longer_used; /* checksum of name. No longer used */ YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; /* The following apply to directories, files, symlinks - not hard links */ - __u32 yst_mode; /* protection */ + u32 yst_mode; /* protection */ -#ifdef CONFIG_YAFFS_WINCE - __u32 not_for_wince[5]; -#else - __u32 yst_uid; - __u32 yst_gid; - __u32 yst_atime; - __u32 yst_mtime; - __u32 yst_ctime; -#endif + u32 yst_uid; + u32 yst_gid; + u32 yst_atime; + u32 yst_mtime; + u32 yst_ctime; /* File size applies to files only */ int file_size; @@ -327,37 +315,29 @@ typedef struct { /* Alias is for symlinks only. */ YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; - __u32 yst_rdev; /* device stuff for block and char devices (major/min) */ + u32 yst_rdev; /* device stuff for block and char devices (major/min) */ -#ifdef CONFIG_YAFFS_WINCE - __u32 win_ctime[2]; - __u32 win_atime[2]; - __u32 win_mtime[2]; -#else - __u32 room_to_grow[6]; + u32 win_ctime[2]; + u32 win_atime[2]; + u32 win_mtime[2]; -#endif - __u32 inband_shadowed_obj_id; - __u32 inband_is_shrink; + u32 inband_shadowed_obj_id; + u32 inband_is_shrink; - __u32 reserved[2]; + u32 reserved[2]; int shadows_obj; /* This object header shadows the specified object if > 0 */ /* is_shrink applies to object headers written when we shrink the file (ie resize) */ - __u32 is_shrink; + u32 is_shrink; -} yaffs_obj_header; +}; /*--------------------------- Tnode -------------------------- */ -union yaffs_tnode_union { - union yaffs_tnode_union *internal[YAFFS_NTNODES_INTERNAL]; - +struct yaffs_tnode { + struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL]; }; -typedef union yaffs_tnode_union yaffs_tnode_t; - - /*------------------------ Object -----------------------------*/ /* An object can be one of: * - a directory (no data, has children links @@ -366,294 +346,280 @@ typedef union yaffs_tnode_union yaffs_tnode_t; * - a hard link */ -typedef struct { - __u32 file_size; - __u32 scanned_size; - __u32 shrink_size; +struct yaffs_file_var { + u32 file_size; + u32 scanned_size; + u32 shrink_size; int top_level; - yaffs_tnode_t *top; -} yaffs_file_s; + struct yaffs_tnode *top; +}; -typedef struct { - struct ylist_head children; /* list of child links */ - struct ylist_head dirty; /* Entry for list of dirty directories */ -} yaffs_dir_s; +struct yaffs_dir_var { + struct list_head children; /* list of child links */ + struct list_head dirty; /* Entry for list of dirty directories */ +}; -typedef struct { +struct yaffs_symlink_var { YCHAR *alias; -} yaffs_symlink_t; - -typedef struct { - struct yaffs_obj_s *equiv_obj; - __u32 equiv_id; -} yaffs_hard_link_s; - -typedef union { - yaffs_file_s file_variant; - yaffs_dir_s dir_variant; - yaffs_symlink_t symlink_variant; - yaffs_hard_link_s hardlink_variant; -} yaffs_obj_variant; - - - -struct yaffs_obj_s { - __u8 deleted:1; /* This should only apply to unlinked files. */ - __u8 soft_del:1; /* it has also been soft deleted */ - __u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory.*/ - __u8 fake:1; /* A fake object has no presence on NAND. */ - __u8 rename_allowed:1; /* Some objects are not allowed to be renamed. */ - __u8 unlink_allowed:1; - __u8 dirty:1; /* the object needs to be written to flash */ - __u8 valid:1; /* When the file system is being loaded up, this +}; + +struct yaffs_hardlink_var { + struct yaffs_obj *equiv_obj; + u32 equiv_id; +}; + +union yaffs_obj_var { + struct yaffs_file_var file_variant; + struct yaffs_dir_var dir_variant; + struct yaffs_symlink_var symlink_variant; + struct yaffs_hardlink_var hardlink_variant; +}; + +struct yaffs_obj { + u8 deleted:1; /* This should only apply to unlinked files. */ + u8 soft_del:1; /* it has also been soft deleted */ + u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory. */ + u8 fake:1; /* A fake object has no presence on NAND. */ + u8 rename_allowed:1; /* Some objects are not allowed to be renamed. */ + u8 unlink_allowed:1; + u8 dirty:1; /* the object needs to be written to flash */ + u8 valid:1; /* When the file system is being loaded up, this * object might be created before the data * is available (ie. file data records appear before the header). */ - __u8 lazy_loaded:1; /* This object has been lazy loaded and is missing some detail */ + u8 lazy_loaded:1; /* This object has been lazy loaded and is missing some detail */ - __u8 defered_free:1; /* For Linux kernel. Object is removed from NAND, but is + u8 defered_free:1; /* For Linux kernel. Object is removed from NAND, but is * still in the inode cache. Free of object is defered. * until the inode is released. */ - __u8 being_created:1; /* This object is still being created so skip some checks. */ - __u8 is_shadowed:1; /* This object is shadowed on the way to being renamed. */ + u8 being_created:1; /* This object is still being created so skip some checks. */ + u8 is_shadowed:1; /* This object is shadowed on the way to being renamed. */ - __u8 xattr_known:1; /* We know if this has object has xattribs or not. */ - __u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */ + u8 xattr_known:1; /* We know if this has object has xattribs or not. */ + u8 has_xattr:1; /* This object has xattribs. Valid if xattr_known. */ - __u8 serial; /* serial number of chunk in NAND. Cached here */ - __u16 sum; /* sum of the name to speed searching */ + u8 serial; /* serial number of chunk in NAND. Cached here */ + u16 sum; /* sum of the name to speed searching */ - struct yaffs_dev_s *my_dev; /* The device I'm on */ + struct yaffs_dev *my_dev; /* The device I'm on */ - struct ylist_head hash_link; /* list of objects in this hash bucket */ + struct list_head hash_link; /* list of objects in this hash bucket */ - struct ylist_head hard_links; /* all the equivalent hard linked objects */ + struct list_head hard_links; /* all the equivalent hard linked objects */ /* directory structure stuff */ /* also used for linking up the free list */ - struct yaffs_obj_s *parent; - struct ylist_head siblings; + struct yaffs_obj *parent; + struct list_head siblings; /* Where's my object header in NAND? */ int hdr_chunk; int n_data_chunks; /* Number of data chunks attached to the file. */ - __u32 obj_id; /* the object id value */ + u32 obj_id; /* the object id value */ - __u32 yst_mode; + u32 yst_mode; #ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1]; #endif #ifdef CONFIG_YAFFS_WINCE - __u32 win_ctime[2]; - __u32 win_mtime[2]; - __u32 win_atime[2]; + u32 win_ctime[2]; + u32 win_mtime[2]; + u32 win_atime[2]; #else - __u32 yst_uid; - __u32 yst_gid; - __u32 yst_atime; - __u32 yst_mtime; - __u32 yst_ctime; + u32 yst_uid; + u32 yst_gid; + u32 yst_atime; + u32 yst_mtime; + u32 yst_ctime; #endif - __u32 yst_rdev; + u32 yst_rdev; void *my_inode; - yaffs_obj_type variant_type; + enum yaffs_obj_type variant_type; - yaffs_obj_variant variant; + union yaffs_obj_var variant; }; -typedef struct yaffs_obj_s yaffs_obj_t; - -typedef struct { - struct ylist_head list; +struct yaffs_obj_bucket { + struct list_head list; int count; -} yaffs_obj_bucket; - +}; -/* yaffs_checkpt_obj_t holds the definition of an object as dumped +/* yaffs_checkpt_obj holds the definition of an object as dumped * by checkpointing. */ -typedef struct { +struct yaffs_checkpt_obj { int struct_type; - __u32 obj_id; - __u32 parent_id; + u32 obj_id; + u32 parent_id; int hdr_chunk; - yaffs_obj_type variant_type:3; - __u8 deleted:1; - __u8 soft_del:1; - __u8 unlinked:1; - __u8 fake:1; - __u8 rename_allowed:1; - __u8 unlink_allowed:1; - __u8 serial; - + enum yaffs_obj_type variant_type:3; + u8 deleted:1; + u8 soft_del:1; + u8 unlinked:1; + u8 fake:1; + u8 rename_allowed:1; + u8 unlink_allowed:1; + u8 serial; int n_data_chunks; - __u32 size_or_equiv_obj; -} yaffs_checkpt_obj_t; + u32 size_or_equiv_obj; +}; /*--------------------- Temporary buffers ---------------- * * These are chunk-sized working buffers. Each device has a few */ -typedef struct { - __u8 *buffer; - int line; /* track from whence this buffer was allocated */ +struct yaffs_buffer { + u8 *buffer; + int line; /* track from whence this buffer was allocated */ int max_line; -} yaffs_buffer_t; +}; /*----------------- Device ---------------------------------*/ - -struct yaffs_param_s { +struct yaffs_param { const YCHAR *name; /* - * Entry parameters set up way early. Yaffs sets up the rest. - * The structure should be zeroed out before use so that unused - * and defualt values are zero. - */ + * Entry parameters set up way early. Yaffs sets up the rest. + * The structure should be zeroed out before use so that unused + * and defualt values are zero. + */ - int inband_tags; /* Use unband tags */ - __u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */ + int inband_tags; /* Use unband tags */ + u32 total_bytes_per_chunk; /* Should be >= 512, does not need to be a power of 2 */ int chunks_per_block; /* does not need to be a power of 2 */ int spare_bytes_per_chunk; /* spare area size */ - int start_block; /* Start block we're allowed to use */ + int start_block; /* Start block we're allowed to use */ int end_block; /* End block we're allowed to use */ int n_reserved_blocks; /* We want this tuneable so that we can reduce */ - /* reserved blocks on NOR and RAM. */ + /* reserved blocks on NOR and RAM. */ - - int n_caches; /* If <= 0, then short op caching is disabled, else + int n_caches; /* If <= 0, then short op caching is disabled, else * the number of short op caches (don't use too many). - * 10 to 20 is a good bet. + * 10 to 20 is a good bet. */ - int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ - int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ + int use_nand_ecc; /* Flag to decide whether or not to use NANDECC on data (yaffs1) */ + int no_tags_ecc; /* Flag to decide whether or not to do ECC on packed tags (yaffs2) */ - int is_yaffs2; /* Use yaffs2 mode on this device */ + int is_yaffs2; /* Use yaffs2 mode on this device */ - int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ + int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ int refresh_period; /* How often we should check to do a block refresh */ /* Checkpoint control. Can be set before or after initialisation */ - __u8 skip_checkpt_rd; - __u8 skip_checkpt_wr; + u8 skip_checkpt_rd; + u8 skip_checkpt_wr; int enable_xattr; /* Enable xattribs */ - /* NAND access functions (Must be set before calling YAFFS)*/ + /* NAND access functions (Must be set before calling YAFFS) */ - int (*write_chunk_fn) (struct yaffs_dev_s *dev, - int nand_chunk, const __u8 *data, - const yaffs_spare *spare); - int (*read_chunk_fn) (struct yaffs_dev_s *dev, - int nand_chunk, __u8 *data, - yaffs_spare *spare); - int (*erase_fn) (struct yaffs_dev_s *dev, - int flash_block); - int (*initialise_flash_fn) (struct yaffs_dev_s *dev); - int (*deinitialise_flash_fn) (struct yaffs_dev_s *dev); + int (*write_chunk_fn) (struct yaffs_dev * dev, + int nand_chunk, const u8 * data, + const struct yaffs_spare * spare); + int (*read_chunk_fn) (struct yaffs_dev * dev, + int nand_chunk, u8 * data, + struct yaffs_spare * spare); + int (*erase_fn) (struct yaffs_dev * dev, int flash_block); + int (*initialise_flash_fn) (struct yaffs_dev * dev); + int (*deinitialise_flash_fn) (struct yaffs_dev * dev); #ifdef CONFIG_YAFFS_YAFFS2 - int (*write_chunk_tags_fn) (struct yaffs_dev_s *dev, - int nand_chunk, const __u8 *data, - const yaffs_ext_tags *tags); - int (*read_chunk_tags_fn) (struct yaffs_dev_s *dev, - int nand_chunk, __u8 *data, - yaffs_ext_tags *tags); - int (*bad_block_fn) (struct yaffs_dev_s *dev, int block_no); - int (*query_block_fn) (struct yaffs_dev_s *dev, int block_no, - yaffs_block_state_t *state, __u32 *seq_number); + int (*write_chunk_tags_fn) (struct yaffs_dev * dev, + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags * tags); + int (*read_chunk_tags_fn) (struct yaffs_dev * dev, + int nand_chunk, u8 * data, + struct yaffs_ext_tags * tags); + int (*bad_block_fn) (struct yaffs_dev * dev, int block_no); + int (*query_block_fn) (struct yaffs_dev * dev, int block_no, + enum yaffs_block_state * state, + u32 * seq_number); #endif /* The remove_obj_fn function must be supplied by OS flavours that * need it. - * yaffs direct uses it to implement the faster readdir. - * Linux uses it to protect the directory during unlocking. + * yaffs direct uses it to implement the faster readdir. + * Linux uses it to protect the directory during unlocking. */ - void (*remove_obj_fn)(struct yaffs_obj_s *obj); + void (*remove_obj_fn) (struct yaffs_obj * obj); /* Callback to mark the superblock dirty */ - void (*sb_dirty_fn)(struct yaffs_dev_s *dev); - + void (*sb_dirty_fn) (struct yaffs_dev * dev); + /* Callback to control garbage collection. */ - unsigned (*gc_control)(struct yaffs_dev_s *dev); + unsigned (*gc_control) (struct yaffs_dev * dev); - /* Debug control flags. Don't use unless you know what you're doing */ + /* Debug control flags. Don't use unless you know what you're doing */ int use_header_file_size; /* Flag to determine if we should use file sizes from the header */ int disable_lazy_load; /* Disable lazy loading on this device */ - int wide_tnodes_disabled; /* Set to disable wide tnodes */ - int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */ - - int defered_dir_update; /* Set to defer directory updates */ + int wide_tnodes_disabled; /* Set to disable wide tnodes */ + int disable_soft_del; /* yaffs 1 only: Set to disable the use of softdeletion. */ + + int defered_dir_update; /* Set to defer directory updates */ #ifdef CONFIG_YAFFS_AUTO_UNICODE int auto_unicode; #endif - int always_check_erased; /* Force chunk erased check always on */ + int always_check_erased; /* Force chunk erased check always on */ }; -typedef struct yaffs_param_s yaffs_param_t; - -struct yaffs_dev_s { - struct yaffs_param_s param; +struct yaffs_dev { + struct yaffs_param param; - /* Context storage. Holds extra OS specific data for this device */ + /* Context storage. Holds extra OS specific data for this device */ void *os_context; void *driver_context; - struct ylist_head dev_list; + struct list_head dev_list; /* Runtime parameters. Set up by YAFFS. */ - int data_bytes_per_chunk; + int data_bytes_per_chunk; - /* Non-wide tnode stuff */ - __u16 chunk_grp_bits; /* Number of bits that need to be resolved if - * the tnodes are not wide enough. - */ - __u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ + /* Non-wide tnode stuff */ + u16 chunk_grp_bits; /* Number of bits that need to be resolved if + * the tnodes are not wide enough. + */ + u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ /* Stuff to support wide tnodes */ - __u32 tnode_width; - __u32 tnode_mask; - __u32 tnode_size; + u32 tnode_width; + u32 tnode_mask; + u32 tnode_size; /* Stuff for figuring out file offset to chunk conversions */ - __u32 chunk_shift; /* Shift value */ - __u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */ - __u32 chunk_mask; /* Mask to use for power-of-2 case */ - - + u32 chunk_shift; /* Shift value */ + u32 chunk_div; /* Divisor after shifting: 1 for power-of-2 sizes */ + u32 chunk_mask; /* Mask to use for power-of-2 case */ int is_mounted; int read_only; int is_checkpointed; - /* Stuff to support block offsetting to support start block zero */ int internal_start_block; int internal_end_block; int block_offset; int chunk_offset; - /* Runtime checkpointing stuff */ - int checkpt_page_seq; /* running sequence number of checkpoint pages */ + int checkpt_page_seq; /* running sequence number of checkpoint pages */ int checkpt_byte_count; int checkpt_byte_offs; - __u8 *checkpt_buffer; + u8 *checkpt_buffer; int checkpt_open_write; int blocks_in_checkpt; int checkpt_cur_chunk; @@ -661,14 +627,14 @@ struct yaffs_dev_s { int checkpt_next_block; int *checkpt_block_list; int checkpt_max_blocks; - __u32 checkpt_sum; - __u32 checkpt_xor; + u32 checkpt_sum; + u32 checkpt_xor; - int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */ + int checkpoint_blocks_required; /* Number of blocks needed to store current checkpoint set */ /* Block Info */ - yaffs_block_info_t *block_info; - __u8 *chunk_bits; /* bitmap of chunks in use */ + struct yaffs_block_info *block_info; + u8 *chunk_bits; /* bitmap of chunks in use */ unsigned block_info_alt:1; /* was allocated using alternative strategy */ unsigned chunk_bits_alt:1; /* was allocated using alternative strategy */ int chunk_bit_stride; /* Number of bytes of chunk_bits per block. @@ -677,7 +643,7 @@ struct yaffs_dev_s { int n_erased_blocks; int alloc_block; /* Current block being allocated off */ - __u32 alloc_page; + u32 alloc_page; int alloc_block_finder; /* Used to search for next allocation block */ /* Object and Tnode memory management */ @@ -687,16 +653,16 @@ struct yaffs_dev_s { int n_hardlinks; - yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; - __u32 bucket_finder; + struct yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; + u32 bucket_finder; int n_free_chunks; /* Garbage collection control */ - __u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ - __u32 n_clean_ups; + u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ + u32 n_clean_ups; - unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */ + unsigned has_pending_prioritised_gc; /* We think this device might have pending prioritised gcs */ unsigned gc_disable; unsigned gc_block_finder; unsigned gc_dirtiest; @@ -707,30 +673,30 @@ struct yaffs_dev_s { unsigned gc_skip; /* Special directories */ - yaffs_obj_t *root_dir; - yaffs_obj_t *lost_n_found; + struct yaffs_obj *root_dir; + struct yaffs_obj *lost_n_found; /* Buffer areas for storing data to recover from write failures TODO - * __u8 buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; - * yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK]; + * u8 buffered_data[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; + * struct yaffs_spare buffered_spare[YAFFS_CHUNKS_PER_BLOCK]; */ int buffered_block; /* Which block is buffered here? */ int doing_buffered_block_rewrite; - yaffs_cache_t *cache; + struct yaffs_cache *cache; int cache_last_use; - /* Stuff for background deletion and unlinked files.*/ - yaffs_obj_t *unlinked_dir; /* Directory where unlinked and deleted files live. */ - yaffs_obj_t *del_dir; /* Directory where deleted objects are sent to disappear. */ - yaffs_obj_t *unlinked_deletion; /* Current file being background deleted.*/ - int n_deleted_files; /* Count of files awaiting deletion;*/ - int n_unlinked_files; /* Count of unlinked files. */ + /* Stuff for background deletion and unlinked files. */ + struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted files live. */ + struct yaffs_obj *del_dir; /* Directory where deleted objects are sent to disappear. */ + struct yaffs_obj *unlinked_deletion; /* Current file being background deleted. */ + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ int n_bg_deletions; /* Count of background deletions. */ /* Temporary buffer management */ - yaffs_buffer_t temp_buffer[YAFFS_N_TEMP_BUFFERS]; + struct yaffs_buffer temp_buffer[YAFFS_N_TEMP_BUFFERS]; int max_temp; int temp_in_use; int unmanaged_buffer_allocs; @@ -745,225 +711,204 @@ struct yaffs_dev_s { int refresh_skip; /* A skip down counter. Refresh happens when this gets to zero. */ /* Dirty directory handling */ - struct ylist_head dirty_dirs; /* List of dirty directories */ - + struct list_head dirty_dirs; /* List of dirty directories */ /* Statistcs */ - __u32 n_page_writes; - __u32 n_page_reads; - __u32 n_erasures; - __u32 n_erase_failures; - __u32 n_gc_copies; - __u32 all_gcs; - __u32 passive_gc_count; - __u32 oldest_dirty_gc_count; - __u32 n_gc_blocks; - __u32 bg_gcs; - __u32 n_retired_writes; - __u32 n_retired_blocks; - __u32 n_ecc_fixed; - __u32 n_ecc_unfixed; - __u32 n_tags_ecc_fixed; - __u32 n_tags_ecc_unfixed; - __u32 n_deletions; - __u32 n_unmarked_deletions; - __u32 refresh_count; - __u32 cache_hits; + u32 n_page_writes; + u32 n_page_reads; + u32 n_erasures; + u32 n_erase_failures; + u32 n_gc_copies; + u32 all_gcs; + u32 passive_gc_count; + u32 oldest_dirty_gc_count; + u32 n_gc_blocks; + u32 bg_gcs; + u32 n_retired_writes; + u32 n_retired_blocks; + u32 n_ecc_fixed; + u32 n_ecc_unfixed; + u32 n_tags_ecc_fixed; + u32 n_tags_ecc_unfixed; + u32 n_deletions; + u32 n_unmarked_deletions; + u32 refresh_count; + u32 cache_hits; }; -typedef struct yaffs_dev_s yaffs_dev_t; - -/* The static layout of block usage etc is stored in the super block header */ -typedef struct { - int StructType; - int version; - int checkpt_start_block; - int checkpt_end_block; - int start_block; - int end_block; - int rfu[100]; -} yaffs_sb_header; - /* The CheckpointDevice structure holds the device information that changes at runtime and * must be preserved over unmount/mount cycles. */ -typedef struct { +struct yaffs_checkpt_dev { int struct_type; int n_erased_blocks; int alloc_block; /* Current block being allocated off */ - __u32 alloc_page; + u32 alloc_page; int n_free_chunks; - int n_deleted_files; /* Count of files awaiting deletion;*/ - int n_unlinked_files; /* Count of unlinked files. */ + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ int n_bg_deletions; /* Count of background deletions. */ /* yaffs2 runtime stuff */ unsigned seq_number; /* Sequence number of currently allocating block */ -} yaffs_checkpt_dev_t; - +}; -typedef struct { +struct yaffs_checkpt_validity { int struct_type; - __u32 magic; - __u32 version; - __u32 head; -} yaffs_checkpt_validty_t; - + u32 magic; + u32 version; + u32 head; +}; -struct yaffs_shadow_fixer_s { +struct yaffs_shadow_fixer { int obj_id; int shadowed_id; - struct yaffs_shadow_fixer_s *next; + struct yaffs_shadow_fixer *next; }; /* Structure for doing xattr modifications */ -typedef struct { - int set; /* If 0 then this is a deletion */ +struct yaffs_xattr_mod { + int set; /* If 0 then this is a deletion */ const YCHAR *name; const void *data; int size; int flags; int result; -}yaffs_xattr_mod; - +}; /*----------------------- YAFFS Functions -----------------------*/ -int yaffs_guts_initialise(yaffs_dev_t *dev); -void yaffs_deinitialise(yaffs_dev_t *dev); +int yaffs_guts_initialise(struct yaffs_dev *dev); +void yaffs_deinitialise(struct yaffs_dev *dev); -int yaffs_get_n_free_chunks(yaffs_dev_t *dev); +int yaffs_get_n_free_chunks(struct yaffs_dev *dev); -int yaffs_rename_obj(yaffs_obj_t *old_dir, const YCHAR *old_name, - yaffs_obj_t *new_dir, const YCHAR *new_name); +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, + struct yaffs_obj *new_dir, const YCHAR * new_name); -int yaffs_unlinker(yaffs_obj_t *dir, const YCHAR *name); -int yaffs_del_obj(yaffs_obj_t *obj); +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name); +int yaffs_del_obj(struct yaffs_obj *obj); -int yaffs_get_obj_name(yaffs_obj_t *obj, YCHAR *name, int buffer_size); -int yaffs_get_obj_length(yaffs_obj_t *obj); -int yaffs_get_obj_inode(yaffs_obj_t *obj); -unsigned yaffs_get_obj_type(yaffs_obj_t *obj); -int yaffs_get_obj_link_count(yaffs_obj_t *obj); - -int yaffs_set_attribs(yaffs_obj_t *obj, struct iattr *attr); -int yaffs_get_attribs(yaffs_obj_t *obj, struct iattr *attr); +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size); +int yaffs_get_obj_length(struct yaffs_obj *obj); +int yaffs_get_obj_inode(struct yaffs_obj *obj); +unsigned yaffs_get_obj_type(struct yaffs_obj *obj); +int yaffs_get_obj_link_count(struct yaffs_obj *obj); /* File operations */ -int yaffs_file_rd(yaffs_obj_t *obj, __u8 *buffer, loff_t offset, - int n_bytes); -int yaffs_wr_file(yaffs_obj_t *obj, const __u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough); -int yaffs_resize_file(yaffs_obj_t *obj, loff_t new_size); +int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset, + int n_bytes); +int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough); +int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size); -yaffs_obj_t *yaffs_create_file(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid); +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid); -int yaffs_flush_file(yaffs_obj_t *obj, int update_time, int data_sync); +int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync); /* Flushing and checkpointing */ -void yaffs_flush_whole_cache(yaffs_dev_t *dev); +void yaffs_flush_whole_cache(struct yaffs_dev *dev); -int yaffs_checkpoint_save(yaffs_dev_t *dev); -int yaffs_checkpoint_restore(yaffs_dev_t *dev); +int yaffs_checkpoint_save(struct yaffs_dev *dev); +int yaffs_checkpoint_restore(struct yaffs_dev *dev); /* Directory operations */ -yaffs_obj_t *yaffs_create_dir(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid); -yaffs_obj_t *yaffs_find_by_name(yaffs_obj_t *the_dir, const YCHAR *name); -int yaffs_ApplyToDirectoryChildren(yaffs_obj_t *the_dir, - int (*fn) (yaffs_obj_t *)); - -yaffs_obj_t *yaffs_find_by_number(yaffs_dev_t *dev, __u32 number); +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR * name, + u32 mode, u32 uid, u32 gid); +struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, + const YCHAR * name); +struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number); /* Link operations */ -yaffs_obj_t *yaffs_link_obj(yaffs_obj_t *parent, const YCHAR *name, - yaffs_obj_t *equiv_obj); +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name, + struct yaffs_obj *equiv_obj); -yaffs_obj_t *yaffs_get_equivalent_obj(yaffs_obj_t *obj); +struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj); /* Symlink operations */ -yaffs_obj_t *yaffs_create_symlink(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, - const YCHAR *alias); -YCHAR *yaffs_get_symlink_alias(yaffs_obj_t *obj); +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, const YCHAR * alias); +YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj); /* Special inodes (fifos, sockets and devices) */ -yaffs_obj_t *yaffs_create_special(yaffs_obj_t *parent, const YCHAR *name, - __u32 mode, __u32 uid, __u32 gid, __u32 rdev); +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR * name, u32 mode, u32 uid, + u32 gid, u32 rdev); - -int yaffs_set_xattrib(yaffs_obj_t *obj, const YCHAR *name, const void * value, int size, int flags); -int yaffs_get_xattrib(yaffs_obj_t *obj, const YCHAR *name, void *value, int size); -int yaffs_list_xattrib(yaffs_obj_t *obj, char *buffer, int size); -int yaffs_remove_xattrib(yaffs_obj_t *obj, const YCHAR *name); +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name, + const void *value, int size, int flags); +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value, + int size); +int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size); +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name); /* Special directories */ -yaffs_obj_t *yaffs_root(yaffs_dev_t *dev); -yaffs_obj_t *yaffs_lost_n_found(yaffs_dev_t *dev); - -#ifdef CONFIG_YAFFS_WINCE -/* CONFIG_YAFFS_WINCE special stuff */ -void yfsd_win_file_time_now(__u32 target[2]); -#endif +struct yaffs_obj *yaffs_root(struct yaffs_dev *dev); +struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev); -void yaffs_handle_defered_free(yaffs_obj_t *obj); +void yaffs_handle_defered_free(struct yaffs_obj *obj); -void yaffs_update_dirty_dirs(yaffs_dev_t *dev); +void yaffs_update_dirty_dirs(struct yaffs_dev *dev); -int yaffs_bg_gc(yaffs_dev_t *dev, unsigned urgency); +int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency); /* Debug dump */ -int yaffs_dump_obj(yaffs_obj_t *obj); +int yaffs_dump_obj(struct yaffs_obj *obj); -void yaffs_guts_test(yaffs_dev_t *dev); +void yaffs_guts_test(struct yaffs_dev *dev); /* A few useful functions to be used within the core files*/ -void yaffs_chunk_del(yaffs_dev_t *dev, int chunk_id, int mark_flash, int lyn); -int yaffs_check_ff(__u8 *buffer, int n_bytes); -void yaffs_handle_chunk_error(yaffs_dev_t *dev, yaffs_block_info_t *bi); - -__u8 *yaffs_get_temp_buffer(yaffs_dev_t *dev, int line_no); -void yaffs_release_temp_buffer(yaffs_dev_t *dev, __u8 *buffer, int line_no); - -yaffs_obj_t *yaffs_find_or_create_by_number(yaffs_dev_t *dev, - int number, - yaffs_obj_type type); -int yaffs_put_chunk_in_file(yaffs_obj_t *in, int inode_chunk, - int nand_chunk, int in_scan); -void yaffs_set_obj_name(yaffs_obj_t *obj, const YCHAR *name); -void yaffs_set_obj_name_from_oh(yaffs_obj_t *obj, const yaffs_obj_header *oh); -void yaffs_add_obj_to_dir(yaffs_obj_t *directory, - yaffs_obj_t *obj); -YCHAR *yaffs_clone_str(const YCHAR *str); -void yaffs_link_fixup(yaffs_dev_t *dev, yaffs_obj_t *hard_list); -void yaffs_block_became_dirty(yaffs_dev_t *dev, int block_no); -int yaffs_update_oh(yaffs_obj_t *in, const YCHAR *name, - int force, int is_shrink, int shadows, - yaffs_xattr_mod *xop); -void yaffs_handle_shadowed_obj(yaffs_dev_t *dev, int obj_id, - int backward_scanning); -int yaffs_check_alloc_available(yaffs_dev_t *dev, int n_chunks); -yaffs_tnode_t *yaffs_get_tnode(yaffs_dev_t *dev); -yaffs_tnode_t *yaffs_add_find_tnode_0(yaffs_dev_t *dev, - yaffs_file_s *file_struct, - __u32 chunk_id, - yaffs_tnode_t *passed_tn); - -int yaffs_do_file_wr(yaffs_obj_t *in, const __u8 *buffer, loff_t offset, - int n_bytes, int write_trhrough); -void yaffs_resize_file_down( yaffs_obj_t *obj, loff_t new_size); -void yaffs_skip_rest_of_block(yaffs_dev_t *dev); - -int yaffs_count_free_chunks(yaffs_dev_t *dev); - -yaffs_tnode_t *yaffs_find_tnode_0(yaffs_dev_t *dev, - yaffs_file_s *file_struct, - __u32 chunk_id); - -__u32 yaffs_get_group_base(yaffs_dev_t *dev, yaffs_tnode_t *tn, unsigned pos); +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn); +int yaffs_check_ff(u8 * buffer, int n_bytes); +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi); + +u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev, int line_no); +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 * buffer, int line_no); + +struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, + int number, + enum yaffs_obj_type type); +int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + int nand_chunk, int in_scan); +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name); +void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, + const struct yaffs_obj_hdr *oh); +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj); +YCHAR *yaffs_clone_str(const YCHAR * str); +void yaffs_link_fixup(struct yaffs_dev *dev, struct yaffs_obj *hard_list); +void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no); +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR * name, + int force, int is_shrink, int shadows, + struct yaffs_xattr_mod *xop); +void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, + int backward_scanning); +int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks); +struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev); +struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn); + +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough); +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size); +void yaffs_skip_rest_of_block(struct yaffs_dev *dev); + +int yaffs_count_free_chunks(struct yaffs_dev *dev); + +struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id); + +u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos); #endif diff --git a/yaffs_linux.h b/yaffs_linux.h index a8e3f85..3b508cb 100644 --- a/yaffs_linux.h +++ b/yaffs_linux.h @@ -16,21 +16,20 @@ #ifndef __YAFFS_LINUX_H__ #define __YAFFS_LINUX_H__ -#include "devextras.h" #include "yportenv.h" struct yaffs_linux_context { - struct ylist_head context_list; /* List of these we have mounted */ - struct yaffs_dev_s *dev; - struct super_block * super; - struct task_struct *bg_thread; /* Background thread for this device */ + struct list_head context_list; /* List of these we have mounted */ + struct yaffs_dev *dev; + struct super_block *super; + struct task_struct *bg_thread; /* Background thread for this device */ int bg_running; - struct semaphore gross_lock; /* Gross locking semaphore */ - __u8 *spare_buffer; /* For mtdif2 use. Don't know the size of the buffer + struct mutex gross_lock; /* Gross locking mutex*/ + u8 *spare_buffer; /* For mtdif2 use. Don't know the size of the buffer * at compile time so we have to allocate it. */ - struct ylist_head search_contexts; - void (*put_super_fn)(struct super_block *sb); + struct list_head search_contexts; + void (*put_super_fn) (struct super_block * sb); struct task_struct *readdir_process; unsigned mount_id; @@ -40,4 +39,3 @@ struct yaffs_linux_context { #define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context)) #endif - diff --git a/yaffs_mtdif.c b/yaffs_mtdif.c index 4fd8994..7cf53b3 100644 --- a/yaffs_mtdif.c +++ b/yaffs_mtdif.c @@ -13,7 +13,6 @@ #include "yportenv.h" - #include "yaffs_mtdif.h" #include "linux/mtd/mtd.h" @@ -23,14 +22,14 @@ #include "yaffs_linux.h" -int nandmtd_erase_block(yaffs_dev_t *dev, int block_no) +int nandmtd_erase_block(struct yaffs_dev *dev, int block_no) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); - __u32 addr = + u32 addr = ((loff_t) block_no) * dev->param.total_bytes_per_chunk - * dev->param.chunks_per_block; + * dev->param.chunks_per_block; struct erase_info ei; - + int retval = 0; ei.mtd = mtd; @@ -49,8 +48,7 @@ int nandmtd_erase_block(yaffs_dev_t *dev, int block_no) return YAFFS_FAIL; } -int nandmtd_initialise(yaffs_dev_t *dev) +int nandmtd_initialise(struct yaffs_dev *dev) { return YAFFS_OK; } - diff --git a/yaffs_mtdif.h b/yaffs_mtdif.h index 919d354..6665074 100644 --- a/yaffs_mtdif.h +++ b/yaffs_mtdif.h @@ -18,10 +18,6 @@ #include "yaffs_guts.h" -#if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 18)) -extern struct nand_oobinfo yaffs_oobinfo; -extern struct nand_oobinfo yaffs_noeccinfo; -#endif -int nandmtd_erase_block(yaffs_dev_t *dev, int block_no); -int nandmtd_initialise(yaffs_dev_t *dev); +int nandmtd_erase_block(struct yaffs_dev *dev, int block_no); +int nandmtd_initialise(struct yaffs_dev *dev); #endif diff --git a/yaffs_mtdif1.h b/yaffs_mtdif1.h index 01a8ec4..07ce452 100644 --- a/yaffs_mtdif1.h +++ b/yaffs_mtdif1.h @@ -14,15 +14,16 @@ #ifndef __YAFFS_MTDIF1_H__ #define __YAFFS_MTDIF1_H__ -int nandmtd1_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, const yaffs_ext_tags *tags); +int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags); -int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, - __u8 *data, yaffs_ext_tags *tags); +int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags); -int nandmtd1_mark_block_bad(struct yaffs_dev_s *dev, int block_no); +int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no); -int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no, - yaffs_block_state_t *state, __u32 *seq_number); +int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 * seq_number); #endif diff --git a/yaffs_mtdif1.c b/yaffs_mtdif1_multi.c similarity index 81% rename from yaffs_mtdif1.c rename to yaffs_mtdif1_multi.c index 6380999..c3ea8c9 100644 --- a/yaffs_mtdif1.c +++ b/yaffs_mtdif1_multi.c @@ -19,7 +19,7 @@ * * These functions are invoked via function pointers in yaffs_nand.c. * This replaces functionality provided by functions in yaffs_mtdif.c - * and the yaffs_tags_tCompatability functions in yaffs_tagscompat.c that are + * and the yaffs_tags compatability functions in yaffs_tagscompat.c that are * called in yaffs_mtdif.c when the function pointers are NULL. * We assume the MTD layer is performing ECC (use_nand_ecc is true). */ @@ -62,9 +62,9 @@ */ static struct nand_ecclayout nand_oob_16 = { .eccbytes = 6, - .eccpos = { 8, 9, 10, 13, 14, 15 }, + .eccpos = {8, 9, 10, 13, 14, 15}, .oobavail = 9, - .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } } + .oobfree = {{0, 4}, {6, 2}, {11, 2}, {4, 1}} }; #endif @@ -89,22 +89,23 @@ static struct nand_ecclayout nand_oob_16 = { * Any underlying MTD error results in YAFFS_FAIL. * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_write_chunk_tags(yaffs_dev_t *dev, - int nand_chunk, const __u8 *data, const yaffs_ext_tags *etags) +int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_bytes = dev->data_bytes_per_chunk; - loff_t addr = ((loff_t)nand_chunk) * chunk_bytes; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; struct mtd_oob_ops ops; - yaffs_packed_tags1 pt1; + struct yaffs_packed_tags1 pt1; int retval; - /* we assume that packed_tags1 and yaffs_tags_t are compatible */ - compile_time_assertion(sizeof(yaffs_packed_tags1) == 12); - compile_time_assertion(sizeof(yaffs_tags_t) == 8); + /* we assume that packed_tags1 and struct yaffs_tags are compatible */ + compile_time_assertion(sizeof(struct yaffs_packed_tags1) == 12); + compile_time_assertion(sizeof(struct yaffs_tags) == 8); yaffs_pack_tags1(&pt1, etags); - yaffs_calc_tags_ecc((yaffs_tags_t *)&pt1); + yaffs_calc_tags_ecc((struct yaffs_tags *)&pt1); /* When deleting a chunk, the upper layer provides only skeletal * etags, one with is_deleted set. However, we need to update the @@ -119,11 +120,11 @@ int nandmtd1_write_chunk_tags(yaffs_dev_t *dev, pt1.deleted = 0; } #else - ((__u8 *)&pt1)[8] = 0xff; + ((u8 *) & pt1)[8] = 0xff; if (etags->is_deleted) { memset(&pt1, 0xff, 8); /* zero page_status byte to indicate deleted */ - ((__u8 *)&pt1)[8] = 0; + ((u8 *) & pt1)[8] = 0; } #endif @@ -131,21 +132,21 @@ int nandmtd1_write_chunk_tags(yaffs_dev_t *dev, ops.mode = MTD_OOB_AUTO; ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; - ops.datbuf = (__u8 *)data; - ops.oobbuf = (__u8 *)&pt1; + ops.datbuf = (u8 *) data; + ops.oobbuf = (u8 *) & pt1; retval = mtd->write_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("write_oob failed, chunk %d, mtd error %d"TENDSTR), - nand_chunk, retval)); + (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } return retval ? YAFFS_FAIL : YAFFS_OK; } /* Return with empty ExtendedTags but add ecc_result. */ -static int rettags(yaffs_ext_tags *etags, int ecc_result, int retval) +static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval) { if (etags) { memset(etags, 0, sizeof(*etags)); @@ -167,15 +168,16 @@ static int rettags(yaffs_ext_tags *etags, int ecc_result, int retval) * * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, - int nand_chunk, __u8 *data, yaffs_ext_tags *etags) +int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, + int nand_chunk, u8 * data, + struct yaffs_ext_tags *etags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_bytes = dev->data_bytes_per_chunk; - loff_t addr = ((loff_t)nand_chunk) * chunk_bytes; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; int eccres = YAFFS_ECC_RESULT_NO_ERROR; struct mtd_oob_ops ops; - yaffs_packed_tags1 pt1; + struct yaffs_packed_tags1 pt1; int retval; int deleted; @@ -184,7 +186,7 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, ops.len = (data) ? chunk_bytes : 0; ops.ooblen = YTAG1_SIZE; ops.datbuf = data; - ops.oobbuf = (__u8 *)&pt1; + ops.oobbuf = (u8 *) & pt1; #if (MTD_VERSION_CODE < MTD_VERSION(2, 6, 20)) /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug; @@ -198,8 +200,8 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, retval = mtd->read_oob(mtd, addr, &ops); if (retval) { T(YAFFS_TRACE_MTD, - (TSTR("read_oob failed, chunk %d, mtd error %d"TENDSTR), - nand_chunk, retval)); + (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); } switch (retval) { @@ -219,17 +221,16 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, /* fall into... */ default: rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0); - etags->block_bad = (mtd->block_isbad)(mtd, addr); + etags->block_bad = (mtd->block_isbad) (mtd, addr); return YAFFS_FAIL; } /* Check for a blank/erased chunk. */ - if (yaffs_check_ff((__u8 *)&pt1, 8)) { + if (yaffs_check_ff((u8 *) & pt1, 8)) { /* when blank, upper layers want ecc_result to be <= NO_ERROR */ return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK); } - #ifndef CONFIG_YAFFS_9BYTE_TAGS /* Read deleted status (bit) then return it to it's non-deleted * state before performing tags mini-ECC check. pt1.deleted is @@ -238,12 +239,12 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, deleted = !pt1.deleted; pt1.deleted = 1; #else - deleted = (yaffs_count_bits(((__u8 *)&pt1)[8]) < 7); + deleted = (yaffs_count_bits(((u8 *) & pt1)[8]) < 7); #endif /* Check the packed tags mini-ECC and correct if necessary/possible. */ - retval = yaffs_check_tags_ecc((yaffs_tags_t *)&pt1); + retval = yaffs_check_tags_ecc((struct yaffs_tags *)&pt1); switch (retval) { case 0: /* no tags error, use MTD result */ @@ -279,15 +280,16 @@ int nandmtd1_read_chunk_tags(yaffs_dev_t *dev, * * Returns YAFFS_OK or YAFFS_FAIL. */ -int nandmtd1_mark_block_bad(struct yaffs_dev_s *dev, int block_no) +int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; int retval; - T(YAFFS_TRACE_BAD_BLOCKS,(TSTR("marking block %d bad"TENDSTR), block_no)); + T(YAFFS_TRACE_BAD_BLOCKS, + (TSTR("marking block %d bad" TENDSTR), block_no)); - retval = mtd->block_markbad(mtd, (loff_t)blocksize * block_no); + retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no); return (retval) ? YAFFS_FAIL : YAFFS_OK; } @@ -303,8 +305,9 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd) if (oobavail < YTAG1_SIZE) { T(YAFFS_TRACE_ERROR, - (TSTR("mtd device has only %d bytes for tags, need %d"TENDSTR), - oobavail, YTAG1_SIZE)); + (TSTR + ("mtd device has only %d bytes for tags, need %d" TENDSTR), + oobavail, YTAG1_SIZE)); return YAFFS_FAIL; } return YAFFS_OK; @@ -319,13 +322,13 @@ static int nandmtd1_test_prerequists(struct mtd_info *mtd) * * Always returns YAFFS_OK. */ -int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no, - yaffs_block_state_t *state_ptr, __u32 *seq_ptr) +int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state_ptr, u32 * seq_ptr) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int chunk_num = block_no * dev->param.chunks_per_block; - loff_t addr = (loff_t)chunk_num * dev->data_bytes_per_chunk; - yaffs_ext_tags etags; + loff_t addr = (loff_t) chunk_num * dev->data_bytes_per_chunk; + struct yaffs_ext_tags etags; int state = YAFFS_BLOCK_STATE_DEAD; int seqnum = 0; int retval; @@ -337,10 +340,10 @@ int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no, return YAFFS_FAIL; retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags); - etags.block_bad = (mtd->block_isbad)(mtd, addr); + etags.block_bad = (mtd->block_isbad) (mtd, addr); if (etags.block_bad) { T(YAFFS_TRACE_BAD_BLOCKS, - (TSTR("block %d is marked bad"TENDSTR), block_no)); + (TSTR("block %d is marked bad" TENDSTR), block_no)); state = YAFFS_BLOCK_STATE_DEAD; } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) { /* bad tags, need to look more closely */ @@ -359,4 +362,4 @@ int nandmtd1_query_block(struct yaffs_dev_s *dev, int block_no, return YAFFS_OK; } -#endif /*MTD_VERSION*/ +#endif /*MTD_VERSION */ diff --git a/yaffs_mtdif1_single.c b/yaffs_mtdif1_single.c new file mode 100644 index 0000000..a0bc04f --- /dev/null +++ b/yaffs_mtdif1_single.c @@ -0,0 +1,331 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +/* + * This module provides the interface between yaffs_nand.c and the + * MTD API. This version is used when the MTD interface supports the + * 'mtd_oob_ops' style calls to read_oob and write_oob, circa 2.6.17, + * and we have small-page NAND device. + * + * These functions are invoked via function pointers in yaffs_nand.c. + * This replaces functionality provided by functions in yaffs_mtdif.c + * and the yaffs_tags compatability functions in yaffs_tagscompat.c that are + * called in yaffs_mtdif.c when the function pointers are NULL. + * We assume the MTD layer is performing ECC (use_nand_ecc is true). + */ + +#include "yportenv.h" +#include "yaffs_trace.h" +#include "yaffs_guts.h" +#include "yaffs_packedtags1.h" +#include "yaffs_tagscompat.h" /* for yaffs_calc_tags_ecc */ +#include "yaffs_linux.h" + +#include "linux/kernel.h" +#include "linux/version.h" +#include "linux/types.h" +#include "linux/mtd/mtd.h" + +#ifndef CONFIG_YAFFS_9BYTE_TAGS +# define YTAG1_SIZE 8 +#else +# define YTAG1_SIZE 9 +#endif + +/* Write a chunk (page) of data to NAND. + * + * Caller always provides ExtendedTags data which are converted to a more + * compact (packed) form for storage in NAND. A mini-ECC runs over the + * contents of the tags meta-data; used to valid the tags when read. + * + * - Pack ExtendedTags to packed_tags1 form + * - Compute mini-ECC for packed_tags1 + * - Write data and packed tags to NAND. + * + * Note: Due to the use of the packed_tags1 meta-data which does not include + * a full sequence number (as found in the larger packed_tags2 form) it is + * necessary for Yaffs to re-write a chunk/page (just once) to mark it as + * discarded and dirty. This is not ideal: newer NAND parts are supposed + * to be written just once. When Yaffs performs this operation, this + * function is called with a NULL data pointer -- calling MTD write_oob + * without data is valid usage (2.6.17). + * + * Any underlying MTD error results in YAFFS_FAIL. + * Returns YAFFS_OK or YAFFS_FAIL. + */ +int nandmtd1_write_chunk_tags(struct yaffs_dev *dev, + int nand_chunk, const u8 * data, + const struct yaffs_ext_tags *etags) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int chunk_bytes = dev->data_bytes_per_chunk; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; + struct mtd_oob_ops ops; + struct yaffs_packed_tags1 pt1; + int retval; + + /* we assume that packed_tags1 and struct yaffs_tags are compatible */ + compile_time_assertion(sizeof(struct yaffs_packed_tags1) == 12); + compile_time_assertion(sizeof(struct yaffs_tags) == 8); + + yaffs_pack_tags1(&pt1, etags); + yaffs_calc_tags_ecc((struct yaffs_tags *)&pt1); + + /* When deleting a chunk, the upper layer provides only skeletal + * etags, one with is_deleted set. However, we need to update the + * tags, not erase them completely. So we use the NAND write property + * that only zeroed-bits stick and set tag bytes to all-ones and + * zero just the (not) deleted bit. + */ +#ifndef CONFIG_YAFFS_9BYTE_TAGS + if (etags->is_deleted) { + memset(&pt1, 0xff, 8); + /* clear delete status bit to indicate deleted */ + pt1.deleted = 0; + } +#else + ((u8 *) & pt1)[8] = 0xff; + if (etags->is_deleted) { + memset(&pt1, 0xff, 8); + /* zero page_status byte to indicate deleted */ + ((u8 *) & pt1)[8] = 0; + } +#endif + + memset(&ops, 0, sizeof(ops)); + ops.mode = MTD_OOB_AUTO; + ops.len = (data) ? chunk_bytes : 0; + ops.ooblen = YTAG1_SIZE; + ops.datbuf = (u8 *) data; + ops.oobbuf = (u8 *) & pt1; + + retval = mtd->write_oob(mtd, addr, &ops); + if (retval) { + T(YAFFS_TRACE_MTD, + (TSTR("write_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); + } + return retval ? YAFFS_FAIL : YAFFS_OK; +} + +/* Return with empty ExtendedTags but add ecc_result. + */ +static int rettags(struct yaffs_ext_tags *etags, int ecc_result, int retval) +{ + if (etags) { + memset(etags, 0, sizeof(*etags)); + etags->ecc_result = ecc_result; + } + return retval; +} + +/* Read a chunk (page) from NAND. + * + * Caller expects ExtendedTags data to be usable even on error; that is, + * all members except ecc_result and block_bad are zeroed. + * + * - Check ECC results for data (if applicable) + * - Check for blank/erased block (return empty ExtendedTags if blank) + * - Check the packed_tags1 mini-ECC (correct if necessary/possible) + * - Convert packed_tags1 to ExtendedTags + * - Update ecc_result and block_bad members to refect state. + * + * Returns YAFFS_OK or YAFFS_FAIL. + */ +int nandmtd1_read_chunk_tags(struct yaffs_dev *dev, + int nand_chunk, u8 * data, + struct yaffs_ext_tags *etags) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int chunk_bytes = dev->data_bytes_per_chunk; + loff_t addr = ((loff_t) nand_chunk) * chunk_bytes; + int eccres = YAFFS_ECC_RESULT_NO_ERROR; + struct mtd_oob_ops ops; + struct yaffs_packed_tags1 pt1; + int retval; + int deleted; + + memset(&ops, 0, sizeof(ops)); + ops.mode = MTD_OOB_AUTO; + ops.len = (data) ? chunk_bytes : 0; + ops.ooblen = YTAG1_SIZE; + ops.datbuf = data; + ops.oobbuf = (u8 *) & pt1; + + /* Read page and oob using MTD. + * Check status and determine ECC result. + */ + retval = mtd->read_oob(mtd, addr, &ops); + if (retval) { + T(YAFFS_TRACE_MTD, + (TSTR("read_oob failed, chunk %d, mtd error %d" TENDSTR), + nand_chunk, retval)); + } + + switch (retval) { + case 0: + /* no error */ + break; + + case -EUCLEAN: + /* MTD's ECC fixed the data */ + eccres = YAFFS_ECC_RESULT_FIXED; + dev->n_ecc_fixed++; + break; + + case -EBADMSG: + /* MTD's ECC could not fix the data */ + dev->n_ecc_unfixed++; + /* fall into... */ + default: + rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0); + etags->block_bad = (mtd->block_isbad) (mtd, addr); + return YAFFS_FAIL; + } + + /* Check for a blank/erased chunk. + */ + if (yaffs_check_ff((u8 *) & pt1, 8)) { + /* when blank, upper layers want ecc_result to be <= NO_ERROR */ + return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK); + } +#ifndef CONFIG_YAFFS_9BYTE_TAGS + /* Read deleted status (bit) then return it to it's non-deleted + * state before performing tags mini-ECC check. pt1.deleted is + * inverted. + */ + deleted = !pt1.deleted; + pt1.deleted = 1; +#else + deleted = (yaffs_count_bits(((u8 *) & pt1)[8]) < 7); +#endif + + /* Check the packed tags mini-ECC and correct if necessary/possible. + */ + retval = yaffs_check_tags_ecc((struct yaffs_tags *)&pt1); + switch (retval) { + case 0: + /* no tags error, use MTD result */ + break; + case 1: + /* recovered tags-ECC error */ + dev->n_tags_ecc_fixed++; + if (eccres == YAFFS_ECC_RESULT_NO_ERROR) + eccres = YAFFS_ECC_RESULT_FIXED; + break; + default: + /* unrecovered tags-ECC error */ + dev->n_tags_ecc_unfixed++; + return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL); + } + + /* Unpack the tags to extended form and set ECC result. + * [set should_be_ff just to keep yaffs_unpack_tags1 happy] + */ + pt1.should_be_ff = 0xFFFFFFFF; + yaffs_unpack_tags1(etags, &pt1); + etags->ecc_result = eccres; + + /* Set deleted state */ + etags->is_deleted = deleted; + return YAFFS_OK; +} + +/* Mark a block bad. + * + * This is a persistant state. + * Use of this function should be rare. + * + * Returns YAFFS_OK or YAFFS_FAIL. + */ +int nandmtd1_mark_block_bad(struct yaffs_dev *dev, int block_no) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int blocksize = dev->param.chunks_per_block * dev->data_bytes_per_chunk; + int retval; + + T(YAFFS_TRACE_BAD_BLOCKS, + (TSTR("marking block %d bad" TENDSTR), block_no)); + + retval = mtd->block_markbad(mtd, (loff_t) blocksize * block_no); + return (retval) ? YAFFS_FAIL : YAFFS_OK; +} + +/* Check any MTD prerequists. + * + * Returns YAFFS_OK or YAFFS_FAIL. + */ +static int nandmtd1_test_prerequists(struct mtd_info *mtd) +{ + /* 2.6.18 has mtd->ecclayout->oobavail */ + /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */ + int oobavail = mtd->ecclayout->oobavail; + + if (oobavail < YTAG1_SIZE) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("mtd device has only %d bytes for tags, need %d" TENDSTR), + oobavail, YTAG1_SIZE)); + return YAFFS_FAIL; + } + return YAFFS_OK; +} + +/* Query for the current state of a specific block. + * + * Examine the tags of the first chunk of the block and return the state: + * - YAFFS_BLOCK_STATE_DEAD, the block is marked bad + * - YAFFS_BLOCK_STATE_NEEDS_SCANNING, the block is in use + * - YAFFS_BLOCK_STATE_EMPTY, the block is clean + * + * Always returns YAFFS_OK. + */ +int nandmtd1_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state_ptr, u32 * seq_ptr) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int chunk_num = block_no * dev->param.chunks_per_block; + loff_t addr = (loff_t) chunk_num * dev->data_bytes_per_chunk; + struct yaffs_ext_tags etags; + int state = YAFFS_BLOCK_STATE_DEAD; + int seqnum = 0; + int retval; + + /* We don't yet have a good place to test for MTD config prerequists. + * Do it here as we are called during the initial scan. + */ + if (nandmtd1_test_prerequists(mtd) != YAFFS_OK) + return YAFFS_FAIL; + + retval = nandmtd1_read_chunk_tags(dev, chunk_num, NULL, &etags); + etags.block_bad = (mtd->block_isbad) (mtd, addr); + if (etags.block_bad) { + T(YAFFS_TRACE_BAD_BLOCKS, + (TSTR("block %d is marked bad" TENDSTR), block_no)); + state = YAFFS_BLOCK_STATE_DEAD; + } else if (etags.ecc_result != YAFFS_ECC_RESULT_NO_ERROR) { + /* bad tags, need to look more closely */ + state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + } else if (etags.chunk_used) { + state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + seqnum = etags.seq_number; + } else { + state = YAFFS_BLOCK_STATE_EMPTY; + } + + *state_ptr = state; + *seq_ptr = seqnum; + + /* query always succeeds */ + return YAFFS_OK; +} diff --git a/yaffs_mtdif2.h b/yaffs_mtdif2.h index b33b84d..d821126 100644 --- a/yaffs_mtdif2.h +++ b/yaffs_mtdif2.h @@ -17,13 +17,13 @@ #define __YAFFS_MTDIF2_H__ #include "yaffs_guts.h" -int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_ext_tags *tags); -int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, - __u8 *data, yaffs_ext_tags *tags); -int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no); -int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no, - yaffs_block_state_t *state, __u32 *seq_number); +int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags); +int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags); +int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no); +int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 * seq_number); #endif diff --git a/yaffs_mtdif2.c b/yaffs_mtdif2_multi.c similarity index 69% rename from yaffs_mtdif2.c rename to yaffs_mtdif2_multi.c index 1c60a44..555f937 100644 --- a/yaffs_mtdif2.c +++ b/yaffs_mtdif2_multi.c @@ -30,9 +30,9 @@ * We assume that the data buffer is of size total_bytes_per_chunk so that we can also * use it to load the tags. */ -int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_ext_tags *tags) +int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) @@ -44,18 +44,19 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, loff_t addr; - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t : (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR ("nandmtd2_write_chunk_tags chunk %d data %p tags %p" TENDSTR), nand_chunk, data, tags)); - - addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; + addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; /* For yaffs2 writing there must be both data and tags. * If we're using inband tags, then the tags are stuffed into @@ -64,8 +65,11 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, if (!data || !tags) BUG(); else if (dev->param.inband_tags) { - yaffs_packed_tags2_tags_only *pt2tp; - pt2tp = (yaffs_packed_tags2_tags_only *)(data + dev->data_bytes_per_chunk); + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)(data + + dev-> + data_bytes_per_chunk); yaffs_pack_tags2_tags_only(pt2tp, tags); } else yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); @@ -75,7 +79,7 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; ops.len = dev->param.total_bytes_per_chunk; ops.ooboffs = 0; - ops.datbuf = (__u8 *)data; + ops.datbuf = (u8 *) data; ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; retval = mtd->write_oob(mtd, addr, &ops); @@ -83,11 +87,11 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, if (!dev->param.inband_tags) { retval = mtd->write_ecc(mtd, addr, dev->data_bytes_per_chunk, - &dummy, data, (__u8 *) packed_tags_ptr, NULL); + &dummy, data, (u8 *) packed_tags_ptr, NULL); } else { retval = - mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, &dummy, - data); + mtd->write(mtd, addr, dev->param.total_bytes_per_chunk, + &dummy, data); } #endif @@ -97,8 +101,8 @@ int nandmtd2_write_chunk_tags(yaffs_dev_t *dev, int nand_chunk, return YAFFS_FAIL; } -int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, - __u8 *data, yaffs_ext_tags *tags) +int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); #if (MTD_VERSION_CODE > MTD_VERSION(2, 6, 17)) @@ -110,10 +114,12 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; - yaffs_packed_tags2 pt; + struct yaffs_packed_tags2 pt; - int packed_tags_size = dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); - void * packed_tags_ptr = dev->param.no_tags_ecc ? (void *) &pt.t: (void *)&pt; + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; T(YAFFS_TRACE_MTD, (TSTR @@ -127,14 +133,12 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, data = yaffs_get_temp_buffer(dev, __LINE__); } - } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) if (dev->param.inband_tags || (data && !tags)) retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk, - &dummy, data); + &dummy, data); else if (tags) { ops.mode = MTD_OOB_AUTO; ops.ooblen = packed_tags_size; @@ -148,13 +152,12 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, if (!dev->param.inband_tags && data && tags) { retval = mtd->read_ecc(mtd, addr, dev->data_bytes_per_chunk, - &dummy, data, dev->spare_buffer, - NULL); + &dummy, data, dev->spare_buffer, NULL); } else { if (data) retval = - mtd->read(mtd, addr, dev->data_bytes_per_chunk, &dummy, - data); + mtd->read(mtd, addr, dev->data_bytes_per_chunk, + &dummy, data); if (!dev->param.inband_tags && tags) retval = mtd->read_oob(mtd, addr, mtd->oobsize, &dummy, @@ -162,16 +165,19 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, } #endif - if (dev->param.inband_tags) { if (tags) { - yaffs_packed_tags2_tags_only *pt2tp; - pt2tp = (yaffs_packed_tags2_tags_only *)&data[dev->data_bytes_per_chunk]; + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)&data[dev-> + data_bytes_per_chunk]; yaffs_unpack_tags2_tags_only(tags, pt2tp); } } else { if (tags) { - memcpy(packed_tags_ptr, yaffs_dev_to_lc(dev)->spare_buffer, packed_tags_size); + memcpy(packed_tags_ptr, + yaffs_dev_to_lc(dev)->spare_buffer, + packed_tags_size); yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); } } @@ -179,11 +185,13 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, if (local_data) yaffs_release_temp_buffer(dev, data, __LINE__); - if (tags && retval == -EBADMSG && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + if (tags && retval == -EBADMSG + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; dev->n_ecc_unfixed++; } - if(tags && retval == -EUCLEAN && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + if (tags && retval == -EUCLEAN + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { tags->ecc_result = YAFFS_ECC_RESULT_FIXED; dev->n_ecc_fixed++; } @@ -193,7 +201,7 @@ int nandmtd2_read_chunk_tags(yaffs_dev_t *dev, int nand_chunk, return YAFFS_FAIL; } -int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no) +int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; @@ -212,14 +220,13 @@ int nandmtd2_mark_block_bad(struct yaffs_dev_s *dev, int block_no) } -int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no, - yaffs_block_state_t *state, __u32 *seq_number) +int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 * seq_number) { struct mtd_info *mtd = yaffs_dev_to_mtd(dev); int retval; - T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); + T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); retval = mtd->block_isbad(mtd, block_no * dev->param.chunks_per_block * @@ -231,10 +238,9 @@ int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no, *state = YAFFS_BLOCK_STATE_DEAD; *seq_number = 0; } else { - yaffs_ext_tags t; + struct yaffs_ext_tags t; nandmtd2_read_chunk_tags(dev, block_no * - dev->param.chunks_per_block, NULL, - &t); + dev->param.chunks_per_block, NULL, &t); if (t.chunk_used) { *seq_number = t.seq_number; @@ -245,12 +251,10 @@ int nandmtd2_query_block(struct yaffs_dev_s *dev, int block_no, } } T(YAFFS_TRACE_MTD, - (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, - *state)); + (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state)); if (retval == 0) return YAFFS_OK; else return YAFFS_FAIL; } - diff --git a/yaffs_mtdif2_single.c b/yaffs_mtdif2_single.c new file mode 100644 index 0000000..00040cd --- /dev/null +++ b/yaffs_mtdif2_single.c @@ -0,0 +1,225 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +/* mtd interface for YAFFS2 */ + +#include "yportenv.h" +#include "yaffs_trace.h" + +#include "yaffs_mtdif2.h" + +#include "linux/mtd/mtd.h" +#include "linux/types.h" +#include "linux/time.h" + +#include "yaffs_packedtags2.h" + +#include "yaffs_linux.h" + +/* NB For use with inband tags.... + * We assume that the data buffer is of size total_bytes_per_chunk so that we can also + * use it to load the tags. + */ +int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 * data, + const struct yaffs_ext_tags *tags) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + struct mtd_oob_ops ops; + int retval = 0; + + loff_t addr; + + struct yaffs_packed_tags2 pt; + + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; + + T(YAFFS_TRACE_MTD, + (TSTR + ("nandmtd2_write_chunk_tags chunk %d data %p tags %p" + TENDSTR), nand_chunk, data, tags)); + + addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; + + /* For yaffs2 writing there must be both data and tags. + * If we're using inband tags, then the tags are stuffed into + * the end of the data buffer. + */ + if (!data || !tags) + BUG(); + else if (dev->param.inband_tags) { + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)(data + + dev-> + data_bytes_per_chunk); + yaffs_pack_tags2_tags_only(pt2tp, tags); + } else + yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); + + ops.mode = MTD_OOB_AUTO; + ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; + ops.len = dev->param.total_bytes_per_chunk; + ops.ooboffs = 0; + ops.datbuf = (u8 *) data; + ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; + retval = mtd->write_oob(mtd, addr, &ops); + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + struct mtd_oob_ops ops; + + size_t dummy; + int retval = 0; + int local_data = 0; + + loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; + + struct yaffs_packed_tags2 pt; + + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; + + T(YAFFS_TRACE_MTD, + (TSTR + ("nandmtd2_read_chunk_tags chunk %d data %p tags %p" + TENDSTR), nand_chunk, data, tags)); + + if (dev->param.inband_tags) { + + if (!data) { + local_data = 1; + data = yaffs_get_temp_buffer(dev, __LINE__); + } + + } + + if (dev->param.inband_tags || (data && !tags)) + retval = mtd->read(mtd, addr, dev->param.total_bytes_per_chunk, + &dummy, data); + else if (tags) { + ops.mode = MTD_OOB_AUTO; + ops.ooblen = packed_tags_size; + ops.len = data ? dev->data_bytes_per_chunk : packed_tags_size; + ops.ooboffs = 0; + ops.datbuf = data; + ops.oobbuf = yaffs_dev_to_lc(dev)->spare_buffer; + retval = mtd->read_oob(mtd, addr, &ops); + } + + if (dev->param.inband_tags) { + if (tags) { + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)&data[dev-> + data_bytes_per_chunk]; + yaffs_unpack_tags2_tags_only(tags, pt2tp); + } + } else { + if (tags) { + memcpy(packed_tags_ptr, + yaffs_dev_to_lc(dev)->spare_buffer, + packed_tags_size); + yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); + } + } + + if (local_data) + yaffs_release_temp_buffer(dev, data, __LINE__); + + if (tags && retval == -EBADMSG + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; + dev->n_ecc_unfixed++; + } + if (tags && retval == -EUCLEAN + && tags->ecc_result == YAFFS_ECC_RESULT_NO_ERROR) { + tags->ecc_result = YAFFS_ECC_RESULT_FIXED; + dev->n_ecc_fixed++; + } + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} + +int nandmtd2_mark_block_bad(struct yaffs_dev *dev, int block_no) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int retval; + T(YAFFS_TRACE_MTD, + (TSTR("nandmtd2_mark_block_bad %d" TENDSTR), block_no)); + + retval = + mtd->block_markbad(mtd, + block_no * dev->param.chunks_per_block * + dev->param.total_bytes_per_chunk); + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; + +} + +int nandmtd2_query_block(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 * seq_number) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + int retval; + + T(YAFFS_TRACE_MTD, (TSTR("nandmtd2_query_block %d" TENDSTR), block_no)); + retval = + mtd->block_isbad(mtd, + block_no * dev->param.chunks_per_block * + dev->param.total_bytes_per_chunk); + + if (retval) { + T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR))); + + *state = YAFFS_BLOCK_STATE_DEAD; + *seq_number = 0; + } else { + struct yaffs_ext_tags t; + nandmtd2_read_chunk_tags(dev, block_no * + dev->param.chunks_per_block, NULL, &t); + + if (t.chunk_used) { + *seq_number = t.seq_number; + *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + } else { + *seq_number = 0; + *state = YAFFS_BLOCK_STATE_EMPTY; + } + } + T(YAFFS_TRACE_MTD, + (TSTR("block is bad seq %d state %d" TENDSTR), *seq_number, *state)); + + if (retval == 0) + return YAFFS_OK; + else + return YAFFS_FAIL; +} diff --git a/yaffs_nameval.c b/yaffs_nameval.c index a4ed297..d7cb72a 100644 --- a/yaffs_nameval.c +++ b/yaffs_nameval.c @@ -25,118 +25,120 @@ * This code has not been tested with unicode yet. */ - #include "yaffs_nameval.h" #include "yportenv.h" - -static int nval_find(const char *xb, int xb_size, const YCHAR *name, - int *exist_size) + +static int nval_find(const char *xb, int xb_size, const YCHAR * name, + int *exist_size) { - int pos=0; + int pos = 0; int size; - memcpy(&size,xb,sizeof(int)); - while(size > 0 && (size < xb_size) && (pos + size < xb_size)){ - if(yaffs_strncmp((YCHAR *)(xb+pos+sizeof(int)),name,size) == 0){ - if(exist_size) + memcpy(&size, xb, sizeof(int)); + while (size > 0 && (size < xb_size) && (pos + size < xb_size)) { + if (yaffs_strncmp + ((YCHAR *) (xb + pos + sizeof(int)), name, size) == 0) { + if (exist_size) *exist_size = size; return pos; } pos += size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } - if(exist_size) + if (exist_size) *exist_size = 0; return -1; } static int nval_used(const char *xb, int xb_size) { - int pos=0; + int pos = 0; int size; - memcpy(&size,xb + pos,sizeof(int)); - while(size > 0 && (size < xb_size) && (pos + size < xb_size)){ + memcpy(&size, xb + pos, sizeof(int)); + while (size > 0 && (size < xb_size) && (pos + size < xb_size)) { pos += size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } return pos; } -int nval_del(char *xb, int xb_size, const YCHAR *name) +int nval_del(char *xb, int xb_size, const YCHAR * name) { - int pos = nval_find(xb, xb_size, name, NULL); + int pos = nval_find(xb, xb_size, name, NULL); int size; - - if(pos >= 0 && pos < xb_size){ + + if (pos >= 0 && pos < xb_size) { /* Find size, shift rest over this record, then zero out the rest of buffer */ - memcpy(&size,xb+pos,sizeof(int)); + memcpy(&size, xb + pos, sizeof(int)); memcpy(xb + pos, xb + pos + size, xb_size - (pos + size)); - memset(xb + (xb_size - size),0,size); + memset(xb + (xb_size - size), 0, size); return 0; } else return -ENODATA; } -int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags) +int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf, + int bsize, int flags) { int pos; - int namelen = yaffs_strnlen(name,xb_size); + int namelen = yaffs_strnlen(name, xb_size); int reclen; int size_exist = 0; int space; int start; - pos = nval_find(xb,xb_size,name, &size_exist); + pos = nval_find(xb, xb_size, name, &size_exist); - if(flags & XATTR_CREATE && pos >= 0) + if (flags & XATTR_CREATE && pos >= 0) return -EEXIST; - if(flags & XATTR_REPLACE && pos < 0) + if (flags & XATTR_REPLACE && pos < 0) return -ENODATA; - start = nval_used(xb,xb_size); + start = nval_used(xb, xb_size); space = xb_size - start + size_exist; reclen = (sizeof(int) + namelen + 1 + bsize); - if(reclen > space) + if (reclen > space) return -ENOSPC; - if(pos >= 0){ - nval_del(xb,xb_size,name); + if (pos >= 0) { + nval_del(xb, xb_size, name); start = nval_used(xb, xb_size); } pos = start; - memcpy(xb + pos,&reclen,sizeof(int)); - pos +=sizeof(int); - yaffs_strncpy((YCHAR *)(xb + pos), name, reclen); - pos+= (namelen+1); - memcpy(xb + pos,buf,bsize); + memcpy(xb + pos, &reclen, sizeof(int)); + pos += sizeof(int); + yaffs_strncpy((YCHAR *) (xb + pos), name, reclen); + pos += (namelen + 1); + memcpy(xb + pos, buf, bsize); return 0; } -int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize) +int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf, + int bsize) { - int pos = nval_find(xb,xb_size,name,NULL); + int pos = nval_find(xb, xb_size, name, NULL); int size; - - if(pos >= 0 && pos< xb_size){ - - memcpy(&size,xb +pos,sizeof(int)); - pos+=sizeof(int); /* advance past record length */ + + if (pos >= 0 && pos < xb_size) { + + memcpy(&size, xb + pos, sizeof(int)); + pos += sizeof(int); /* advance past record length */ size -= sizeof(int); /* Advance over name string */ - while(xb[pos] && size > 0 && pos < xb_size){ + while (xb[pos] && size > 0 && pos < xb_size) { pos++; size--; } @@ -144,13 +146,13 @@ int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsiz pos++; size--; - if(size <= bsize){ - memcpy(buf,xb + pos,size); + if (size <= bsize) { + memcpy(buf, xb + pos, size); return size; } - + } - if(pos >= 0) + if (pos >= 0) return -ERANGE; else return -ENODATA; @@ -164,33 +166,33 @@ int nval_list(const char *xb, int xb_size, char *buf, int bsize) int ncopied = 0; int filled = 0; - memcpy(&size,xb + pos,sizeof(int)); - while(size > sizeof(int) && size <= xb_size && (pos + size) < xb_size && !filled){ - pos+= sizeof(int); - size-=sizeof(int); - name_len = yaffs_strnlen((YCHAR *)(xb + pos), size); - if(ncopied + name_len + 1 < bsize){ - memcpy(buf,xb+pos,name_len * sizeof(YCHAR)); - buf+= name_len; + memcpy(&size, xb + pos, sizeof(int)); + while (size > sizeof(int) && size <= xb_size && (pos + size) < xb_size + && !filled) { + pos += sizeof(int); + size -= sizeof(int); + name_len = yaffs_strnlen((YCHAR *) (xb + pos), size); + if (ncopied + name_len + 1 < bsize) { + memcpy(buf, xb + pos, name_len * sizeof(YCHAR)); + buf += name_len; *buf = '\0'; buf++; - if(sizeof(YCHAR) > 1){ + if (sizeof(YCHAR) > 1) { *buf = '\0'; buf++; } - ncopied += (name_len+1); + ncopied += (name_len + 1); } else filled = 1; - pos+=size; - if(pos < xb_size -sizeof(int)) - memcpy(&size,xb + pos,sizeof(int)); + pos += size; + if (pos < xb_size - sizeof(int)) + memcpy(&size, xb + pos, sizeof(int)); else size = 0; } return ncopied; } - int nval_hasvalues(const char *xb, int xb_size) { return nval_used(xb, xb_size) > 0; diff --git a/yaffs_nameval.h b/yaffs_nameval.h index bd80859..2bb02b6 100644 --- a/yaffs_nameval.h +++ b/yaffs_nameval.h @@ -18,9 +18,11 @@ #include "yportenv.h" -int nval_del(char *xb, int xb_size, const YCHAR *name); -int nval_set(char *xb, int xb_size, const YCHAR *name, const char *buf, int bsize, int flags); -int nval_get(const char *xb, int xb_size, const YCHAR *name, char *buf, int bsize); +int nval_del(char *xb, int xb_size, const YCHAR * name); +int nval_set(char *xb, int xb_size, const YCHAR * name, const char *buf, + int bsize, int flags); +int nval_get(const char *xb, int xb_size, const YCHAR * name, char *buf, + int bsize); int nval_list(const char *xb, int xb_size, char *buf, int bsize); int nval_hasvalues(const char *xb, int xb_size); #endif diff --git a/yaffs_nand.c b/yaffs_nand.c index d721fa6..84ab0f0 100644 --- a/yaffs_nand.c +++ b/yaffs_nand.c @@ -17,12 +17,11 @@ #include "yaffs_getblockinfo.h" -int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk, - __u8 *buffer, - yaffs_ext_tags *tags) +int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, + u8 * buffer, struct yaffs_ext_tags *tags) { int result; - yaffs_ext_tags local_tags; + struct yaffs_ext_tags local_tags; int realigned_chunk = nand_chunk - dev->chunk_offset; @@ -33,35 +32,33 @@ int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk, tags = &local_tags; if (dev->param.read_chunk_tags_fn) - result = dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer, - tags); + result = + dev->param.read_chunk_tags_fn(dev, realigned_chunk, buffer, + tags); else result = yaffs_tags_compat_rd(dev, - realigned_chunk, - buffer, - tags); - if (tags && - tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { - - yaffs_block_info_t *bi; - bi = yaffs_get_block_info(dev, nand_chunk/dev->param.chunks_per_block); + realigned_chunk, buffer, tags); + if (tags && tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { + + struct yaffs_block_info *bi; + bi = yaffs_get_block_info(dev, + nand_chunk / + dev->param.chunks_per_block); yaffs_handle_chunk_error(dev, bi); } return result; } -int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev, - int nand_chunk, - const __u8 *buffer, - yaffs_ext_tags *tags) +int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, + int nand_chunk, + const u8 * buffer, struct yaffs_ext_tags *tags) { dev->n_page_writes++; nand_chunk -= dev->chunk_offset; - if (tags) { tags->seq_number = dev->seq_number; tags->chunk_used = 1; @@ -80,43 +77,37 @@ int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev, if (dev->param.write_chunk_tags_fn) return dev->param.write_chunk_tags_fn(dev, nand_chunk, buffer, - tags); + tags); else - return yaffs_tags_compat_wr(dev, - nand_chunk, - buffer, - tags); + return yaffs_tags_compat_wr(dev, nand_chunk, buffer, tags); } -int yaffs_mark_bad(yaffs_dev_t *dev, int block_no) +int yaffs_mark_bad(struct yaffs_dev *dev, int block_no) { block_no -= dev->block_offset; - if (dev->param.bad_block_fn) return dev->param.bad_block_fn(dev, block_no); else return yaffs_tags_compat_mark_bad(dev, block_no); } -int yaffs_query_init_block_state(yaffs_dev_t *dev, - int block_no, - yaffs_block_state_t *state, - __u32 *seq_number) +int yaffs_query_init_block_state(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 * seq_number) { block_no -= dev->block_offset; if (dev->param.query_block_fn) - return dev->param.query_block_fn(dev, block_no, state, seq_number); + return dev->param.query_block_fn(dev, block_no, state, + seq_number); else return yaffs_tags_compat_query_block(dev, block_no, - state, - seq_number); + state, seq_number); } - -int yaffs_erase_block(struct yaffs_dev_s *dev, - int flash_block) +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block) { int result; @@ -129,12 +120,9 @@ int yaffs_erase_block(struct yaffs_dev_s *dev, return result; } -int yaffs_init_nand(struct yaffs_dev_s *dev) +int yaffs_init_nand(struct yaffs_dev *dev) { - if(dev->param.initialise_flash_fn) + if (dev->param.initialise_flash_fn) return dev->param.initialise_flash_fn(dev); return YAFFS_OK; } - - - diff --git a/yaffs_nand.h b/yaffs_nand.h index 24cd147..543f198 100644 --- a/yaffs_nand.h +++ b/yaffs_nand.h @@ -17,28 +17,22 @@ #define __YAFFS_NAND_H__ #include "yaffs_guts.h" +int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, + u8 * buffer, struct yaffs_ext_tags *tags); +int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, + int nand_chunk, + const u8 * buffer, struct yaffs_ext_tags *tags); -int yaffs_rd_chunk_tags_nand(yaffs_dev_t *dev, int nand_chunk, - __u8 *buffer, - yaffs_ext_tags *tags); +int yaffs_mark_bad(struct yaffs_dev *dev, int block_no); -int yaffs_wr_chunk_tags_nand(yaffs_dev_t *dev, - int nand_chunk, - const __u8 *buffer, - yaffs_ext_tags *tags); +int yaffs_query_init_block_state(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + unsigned *seq_number); -int yaffs_mark_bad(yaffs_dev_t *dev, int block_no); +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block); -int yaffs_query_init_block_state(yaffs_dev_t *dev, - int block_no, - yaffs_block_state_t *state, - unsigned *seq_number); - -int yaffs_erase_block(struct yaffs_dev_s *dev, - int flash_block); - -int yaffs_init_nand(struct yaffs_dev_s *dev); +int yaffs_init_nand(struct yaffs_dev *dev); #endif - diff --git a/yaffs_packedtags1.c b/yaffs_packedtags1.c index 2ce873f..a77f095 100644 --- a/yaffs_packedtags1.c +++ b/yaffs_packedtags1.c @@ -14,7 +14,8 @@ #include "yaffs_packedtags1.h" #include "yportenv.h" -void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const yaffs_ext_tags *t) +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t) { pt->chunk_id = t->chunk_id; pt->serial_number = t->serial_number; @@ -27,13 +28,15 @@ void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const yaffs_ext_tags *t) } -void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_packed_tags1 *pt) +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt) { - static const __u8 all_ff[] = + static const u8 all_ff[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, -0xff }; + 0xff + }; - if (memcmp(all_ff, pt, sizeof(yaffs_packed_tags1))) { + if (memcmp(all_ff, pt, sizeof(struct yaffs_packed_tags1))) { t->block_bad = 0; if (pt->should_be_ff != 0xFFFFFFFF) t->block_bad = 1; @@ -45,6 +48,6 @@ void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_packed_tags1 *pt) t->is_deleted = (pt->deleted) ? 0 : 1; t->serial_number = pt->serial_number; } else { - memset(t, 0, sizeof(yaffs_ext_tags)); + memset(t, 0, sizeof(struct yaffs_ext_tags)); } } diff --git a/yaffs_packedtags1.h b/yaffs_packedtags1.h index 50f32e8..d6861ff 100644 --- a/yaffs_packedtags1.h +++ b/yaffs_packedtags1.h @@ -20,7 +20,7 @@ #include "yaffs_guts.h" -typedef struct { +struct yaffs_packed_tags1 { unsigned chunk_id:20; unsigned serial_number:2; unsigned n_bytes:10; @@ -30,8 +30,10 @@ typedef struct { unsigned unused_stuff:1; unsigned should_be_ff; -} yaffs_packed_tags1; +}; -void yaffs_pack_tags1(yaffs_packed_tags1 *pt, const yaffs_ext_tags *t); -void yaffs_unpack_tags1(yaffs_ext_tags *t, const yaffs_packed_tags1 *pt); +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt); #endif diff --git a/yaffs_packedtags2.c b/yaffs_packedtags2.c index 4873f78..6c12aed 100644 --- a/yaffs_packedtags2.c +++ b/yaffs_packedtags2.c @@ -38,20 +38,20 @@ #define EXTRA_OBJECT_TYPE_SHIFT (28) #define EXTRA_OBJECT_TYPE_MASK ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT) - -static void yaffs_dump_packed_tags2_tags_only(const yaffs_packed_tags2_tags_only *ptt) +static void yaffs_dump_packed_tags2_tags_only(const struct + yaffs_packed_tags2_tags_only *ptt) { T(YAFFS_TRACE_MTD, (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR), - ptt->obj_id, ptt->chunk_id, ptt->n_bytes, - ptt->seq_number)); + ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number)); } -static void yaffs_dump_packed_tags2(const yaffs_packed_tags2 *pt) + +static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt) { yaffs_dump_packed_tags2_tags_only(&pt->t); } -static void yaffs_dump_tags2(const yaffs_ext_tags *t) +static void yaffs_dump_tags2(const struct yaffs_ext_tags *t) { T(YAFFS_TRACE_MTD, (TSTR @@ -62,8 +62,8 @@ static void yaffs_dump_tags2(const yaffs_ext_tags *t) } -void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *ptt, - const yaffs_ext_tags *t) +void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt, + const struct yaffs_ext_tags *t) { ptt->chunk_id = t->chunk_id; ptt->seq_number = t->seq_number; @@ -73,16 +73,14 @@ void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *ptt, if (t->chunk_id == 0 && t->extra_available) { /* Store the extra header info instead */ /* We save the parent object in the chunk_id */ - ptt->chunk_id = EXTRA_HEADER_INFO_FLAG - | t->extra_parent_id; + ptt->chunk_id = EXTRA_HEADER_INFO_FLAG | t->extra_parent_id; if (t->extra_is_shrink) ptt->chunk_id |= EXTRA_SHRINK_FLAG; if (t->extra_shadows) ptt->chunk_id |= EXTRA_SHADOWS_FLAG; ptt->obj_id &= ~EXTRA_OBJECT_TYPE_MASK; - ptt->obj_id |= - (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT); + ptt->obj_id |= (t->extra_obj_type << EXTRA_OBJECT_TYPE_SHIFT); if (t->extra_obj_type == YAFFS_OBJECT_TYPE_HARDLINK) ptt->n_bytes = t->extra_equiv_id; @@ -96,23 +94,23 @@ void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *ptt, yaffs_dump_tags2(t); } - -void yaffs_pack_tags2(yaffs_packed_tags2 *pt, const yaffs_ext_tags *t, int tags_ecc) +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc) { yaffs_pack_tags2_tags_only(&pt->t, t); - if(tags_ecc) + if (tags_ecc) yaffs_ecc_calc_other((unsigned char *)&pt->t, - sizeof(yaffs_packed_tags2_tags_only), - &pt->ecc); + sizeof(struct + yaffs_packed_tags2_tags_only), + &pt->ecc); } - -void yaffs_unpack_tags2_tags_only(yaffs_ext_tags *t, - yaffs_packed_tags2_tags_only *ptt) +void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, + struct yaffs_packed_tags2_tags_only *ptt) { - memset(t, 0, sizeof(yaffs_ext_tags)); + memset(t, 0, sizeof(struct yaffs_ext_tags)); yaffs_init_tags(t); @@ -155,36 +153,38 @@ void yaffs_unpack_tags2_tags_only(yaffs_ext_tags *t, } - -void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_packed_tags2 *pt, int tags_ecc) +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc) { - yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - if (pt->t.seq_number != 0xFFFFFFFF && - tags_ecc){ + if (pt->t.seq_number != 0xFFFFFFFF && tags_ecc) { /* Chunk is in use and we need to do ECC */ - - yaffs_ecc_other ecc; + + struct yaffs_ecc_other ecc; int result; yaffs_ecc_calc_other((unsigned char *)&pt->t, - sizeof(yaffs_packed_tags2_tags_only), - &ecc); - result = yaffs_ecc_correct_other((unsigned char *)&pt->t, - sizeof(yaffs_packed_tags2_tags_only), - &pt->ecc, &ecc); + sizeof(struct + yaffs_packed_tags2_tags_only), + &ecc); + result = + yaffs_ecc_correct_other((unsigned char *)&pt->t, + sizeof(struct + yaffs_packed_tags2_tags_only), + &pt->ecc, &ecc); switch (result) { - case 0: - ecc_result = YAFFS_ECC_RESULT_NO_ERROR; - break; - case 1: - ecc_result = YAFFS_ECC_RESULT_FIXED; - break; - case -1: - ecc_result = YAFFS_ECC_RESULT_UNFIXED; - break; - default: - ecc_result = YAFFS_ECC_RESULT_UNKNOWN; + case 0: + ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + break; + case 1: + ecc_result = YAFFS_ECC_RESULT_FIXED; + break; + case -1: + ecc_result = YAFFS_ECC_RESULT_UNFIXED; + break; + default: + ecc_result = YAFFS_ECC_RESULT_UNKNOWN; } } @@ -195,4 +195,3 @@ void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_packed_tags2 *pt, int tags_ecc) yaffs_dump_packed_tags2(pt); yaffs_dump_tags2(t); } - diff --git a/yaffs_packedtags2.h b/yaffs_packedtags2.h index fd7a239..f329669 100644 --- a/yaffs_packedtags2.h +++ b/yaffs_packedtags2.h @@ -21,23 +21,27 @@ #include "yaffs_guts.h" #include "yaffs_ecc.h" -typedef struct { +struct yaffs_packed_tags2_tags_only { unsigned seq_number; unsigned obj_id; unsigned chunk_id; unsigned n_bytes; -} yaffs_packed_tags2_tags_only; +}; -typedef struct { - yaffs_packed_tags2_tags_only t; - yaffs_ecc_other ecc; -} yaffs_packed_tags2; +struct yaffs_packed_tags2 { + struct yaffs_packed_tags2_tags_only t; + struct yaffs_ecc_other ecc; +}; /* Full packed tags with ECC, used for oob tags */ -void yaffs_pack_tags2(yaffs_packed_tags2 *pt, const yaffs_ext_tags *t, int tags_ecc); -void yaffs_unpack_tags2(yaffs_ext_tags *t, yaffs_packed_tags2 *pt, int tags_ecc); +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc); +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc); /* Only the tags part (no ECC for use with inband tags */ -void yaffs_pack_tags2_tags_only(yaffs_packed_tags2_tags_only *pt, const yaffs_ext_tags *t); -void yaffs_unpack_tags2_tags_only(yaffs_ext_tags *t, yaffs_packed_tags2_tags_only *pt); +void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, + struct yaffs_packed_tags2_tags_only *pt); #endif diff --git a/yaffs_tagscompat.c b/yaffs_tagscompat.c index 1e910f2..3a9a157 100644 --- a/yaffs_tagscompat.c +++ b/yaffs_tagscompat.c @@ -17,16 +17,7 @@ #include "yaffs_getblockinfo.h" #include "yaffs_trace.h" -static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk); -#ifdef NOTYET -static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk); -static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_spare *spare); -static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, - const yaffs_spare *spare); -static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk); -#endif +static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk); static const char yaffs_count_bits_table[256] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, @@ -47,7 +38,7 @@ static const char yaffs_count_bits_table[256] = { 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 }; -int yaffs_count_bits(__u8 x) +int yaffs_count_bits(u8 x) { int ret_val; ret_val = yaffs_count_bits_table[x]; @@ -56,17 +47,17 @@ int yaffs_count_bits(__u8 x) /********** Tags ECC calculations *********/ -void yaffs_calc_ecc(const __u8 *data, yaffs_spare *spare) +void yaffs_calc_ecc(const u8 * data, struct yaffs_spare *spare) { yaffs_ecc_cacl(data, spare->ecc1); yaffs_ecc_cacl(&data[256], spare->ecc2); } -void yaffs_calc_tags_ecc(yaffs_tags_t *tags) +void yaffs_calc_tags_ecc(struct yaffs_tags *tags) { /* Calculate an ecc */ - unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; unsigned i, j; unsigned ecc = 0; unsigned bit = 0; @@ -85,7 +76,7 @@ void yaffs_calc_tags_ecc(yaffs_tags_t *tags) } -int yaffs_check_tags_ecc(yaffs_tags_t *tags) +int yaffs_check_tags_ecc(struct yaffs_tags *tags) { unsigned ecc = tags->ecc; @@ -95,7 +86,7 @@ int yaffs_check_tags_ecc(yaffs_tags_t *tags) if (ecc && ecc <= 64) { /* TODO: Handle the failure better. Retire? */ - unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; ecc--; @@ -116,10 +107,10 @@ int yaffs_check_tags_ecc(yaffs_tags_t *tags) /********** Tags **********/ -static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr, - yaffs_tags_t *tags_ptr) +static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; yaffs_calc_tags_ecc(tags_ptr); @@ -133,10 +124,11 @@ static void yaffs_load_tags_to_spare(yaffs_spare *spare_ptr, spare_ptr->tb7 = tu->as_bytes[7]; } -static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *spare_ptr, - yaffs_tags_t *tags_ptr) +static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, + struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr; + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; int result; tu->as_bytes[0] = spare_ptr->tb0; @@ -155,14 +147,14 @@ static void yaffs_get_tags_from_spare(yaffs_dev_t *dev, yaffs_spare *spare_ptr, dev->n_tags_ecc_unfixed++; } -static void yaffs_spare_init(yaffs_spare *spare) +static void yaffs_spare_init(struct yaffs_spare *spare) { - memset(spare, 0xFF, sizeof(yaffs_spare)); + memset(spare, 0xFF, sizeof(struct yaffs_spare)); } -static int yaffs_wr_nand(struct yaffs_dev_s *dev, - int nand_chunk, const __u8 *data, - yaffs_spare *spare) +static int yaffs_wr_nand(struct yaffs_dev *dev, + int nand_chunk, const u8 * data, + struct yaffs_spare *spare) { if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { T(YAFFS_TRACE_ERROR, @@ -174,15 +166,15 @@ static int yaffs_wr_nand(struct yaffs_dev_s *dev, return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); } -static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, - int nand_chunk, - __u8 *data, - yaffs_spare *spare, - yaffs_ecc_result *ecc_result, - int correct_errors) +static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, + int nand_chunk, + u8 * data, + struct yaffs_spare *spare, + enum yaffs_ecc_result *ecc_result, + int correct_errors) { int ret_val; - yaffs_spare local_spare; + struct yaffs_spare local_spare; if (!spare && data) { /* If we don't have a real spare, then we use a local one. */ @@ -191,19 +183,21 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, } if (!dev->param.use_nand_ecc) { - ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, spare); + ret_val = + dev->param.read_chunk_fn(dev, nand_chunk, data, spare); if (data && correct_errors) { /* Do ECC correction */ /* Todo handle any errors */ int ecc_result1, ecc_result2; - __u8 calc_ecc[3]; + u8 calc_ecc[3]; yaffs_ecc_cacl(data, calc_ecc); ecc_result1 = yaffs_ecc_correct(data, spare->ecc1, calc_ecc); yaffs_ecc_cacl(&data[256], calc_ecc); ecc_result2 = - yaffs_ecc_correct(&data[256], spare->ecc2, calc_ecc); + yaffs_ecc_correct(&data[256], spare->ecc2, + calc_ecc); if (ecc_result1 > 0) { T(YAFFS_TRACE_ERROR, @@ -253,8 +247,9 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, memset(&nspare, 0, sizeof(nspare)); ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, - (yaffs_spare *) &nspare); - memcpy(spare, &nspare, sizeof(yaffs_spare)); + (struct yaffs_spare *) + &nspare); + memcpy(spare, &nspare, sizeof(struct yaffs_spare)); if (data && correct_errors) { if (nspare.eccres1 > 0) { T(YAFFS_TRACE_ERROR, @@ -297,44 +292,18 @@ static int yaffs_rd_chunk_nand(struct yaffs_dev_s *dev, return ret_val; } -#ifdef NOTYET -static int yaffs_check_chunk_erased(struct yaffs_dev_s *dev, - int nand_chunk) -{ - static int init; - static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; - static __u8 data[YAFFS_BYTES_PER_CHUNK]; - /* Might as well always allocate the larger size for */ - /* dev->param.use_nand_ecc == true; */ - static __u8 spare[sizeof(struct yaffs_nand_spare)]; - - dev->param.read_chunk_fn(dev, nand_chunk, data, (yaffs_spare *) spare); - - if (!init) { - memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK); - init = 1; - } - - if (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK)) - return YAFFS_FAIL; - if (memcmp(cmpbuf, spare, 16)) - return YAFFS_FAIL; - - return YAFFS_OK; - -} -#endif - /* * Functions for robustisizing */ -static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) +static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk) { int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_get_block_info(dev, flash_block + dev->block_offset)->needs_retiring = 1; + yaffs_get_block_info(dev, + flash_block + dev->block_offset)->needs_retiring = + 1; T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, (TSTR("**>>Block %d marked for retirement" TENDSTR), flash_block)); @@ -345,64 +314,12 @@ static void yaffs_handle_rd_data_error(yaffs_dev_t *dev, int nand_chunk) */ } -#ifdef NOTYET -static void yaffs_check_written_block(yaffs_dev_t *dev, int nand_chunk) +int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, const struct yaffs_ext_tags *ext_tags) { -} - -static void yaffs_handle_chunk_wr_ok(yaffs_dev_t *dev, int nand_chunk, - const __u8 *data, - const yaffs_spare *spare) -{ -} - -static void yaffs_handle_chunk_update(yaffs_dev_t *dev, int nand_chunk, - const yaffs_spare *spare) -{ -} - -static void yaffs_handle_chunk_wr_error(yaffs_dev_t *dev, int nand_chunk) -{ - int flash_block = nand_chunk / dev->param.chunks_per_block; - - /* Mark the block for retirement */ - yaffs_get_block_info(dev, flash_block)->needs_retiring = 1; - /* Delete the chunk */ - yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); -} - -static int yaffs_verify_cmp(const __u8 *d0, const __u8 *d1, - const yaffs_spare *s0, const yaffs_spare *s1) -{ - - if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || - s0->tb0 != s1->tb0 || - s0->tb1 != s1->tb1 || - s0->tb2 != s1->tb2 || - s0->tb3 != s1->tb3 || - s0->tb4 != s1->tb4 || - s0->tb5 != s1->tb5 || - s0->tb6 != s1->tb6 || - s0->tb7 != s1->tb7 || - s0->ecc1[0] != s1->ecc1[0] || - s0->ecc1[1] != s1->ecc1[1] || - s0->ecc1[2] != s1->ecc1[2] || - s0->ecc2[0] != s1->ecc2[0] || - s0->ecc2[1] != s1->ecc2[1] || s0->ecc2[2] != s1->ecc2[2]) { - return 0; - } - - return 1; -} -#endif /* NOTYET */ - -int yaffs_tags_compat_wr(yaffs_dev_t *dev, - int nand_chunk, - const __u8 *data, - const yaffs_ext_tags *ext_tags) -{ - yaffs_spare spare; - yaffs_tags_t tags; + struct yaffs_spare spare; + struct yaffs_tags tags; yaffs_spare_init(&spare); @@ -419,7 +336,6 @@ int yaffs_tags_compat_wr(yaffs_dev_t *dev, else tags.n_bytes_msb = 3; - tags.serial_number = ext_tags->serial_number; if (!dev->param.use_nand_ecc && data) @@ -432,17 +348,16 @@ int yaffs_tags_compat_wr(yaffs_dev_t *dev, return yaffs_wr_nand(dev, nand_chunk, data, &spare); } -int yaffs_tags_compat_rd(yaffs_dev_t *dev, - int nand_chunk, - __u8 *data, - yaffs_ext_tags *ext_tags) +int yaffs_tags_compat_rd(struct yaffs_dev *dev, + int nand_chunk, + u8 * data, struct yaffs_ext_tags *ext_tags) { - yaffs_spare spare; - yaffs_tags_t tags; - yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; + struct yaffs_spare spare; + struct yaffs_tags tags; + enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; - static yaffs_spare spare_ff; + static struct yaffs_spare spare_ff; static int init; if (!init) { @@ -450,8 +365,7 @@ int yaffs_tags_compat_rd(yaffs_dev_t *dev, init = 1; } - if (yaffs_rd_chunk_nand - (dev, nand_chunk, data, &spare, &ecc_result, 1)) { + if (yaffs_rd_chunk_nand(dev, nand_chunk, data, &spare, &ecc_result, 1)) { /* ext_tags may be NULL */ if (ext_tags) { @@ -474,7 +388,9 @@ int yaffs_tags_compat_rd(yaffs_dev_t *dev, ext_tags->n_bytes = tags.n_bytes_lsb; if (dev->data_bytes_per_chunk >= 1024) - ext_tags->n_bytes |= (((unsigned) tags.n_bytes_msb) << 10); + ext_tags->n_bytes |= + (((unsigned)tags. + n_bytes_msb) << 10); ext_tags->serial_number = tags.serial_number; } @@ -486,35 +402,34 @@ int yaffs_tags_compat_rd(yaffs_dev_t *dev, } } -int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, - int flash_block) +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block) { - yaffs_spare spare; + struct yaffs_spare spare; - memset(&spare, 0xff, sizeof(yaffs_spare)); + memset(&spare, 0xff, sizeof(struct yaffs_spare)); spare.block_status = 'Y'; yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block, NULL, - &spare); + &spare); yaffs_wr_nand(dev, flash_block * dev->param.chunks_per_block + 1, - NULL, &spare); + NULL, &spare); return YAFFS_OK; } -int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, - int block_no, - yaffs_block_state_t *state, - __u32 *seq_number) +int yaffs_tags_compat_query_block(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 * seq_number) { - yaffs_spare spare0, spare1; - static yaffs_spare spare_ff; + struct yaffs_spare spare0, spare1; + static struct yaffs_spare spare_ff; static int init; - yaffs_ecc_result dummy; + enum yaffs_ecc_result dummy; if (!init) { memset(&spare_ff, 0xFF, sizeof(spare_ff)); @@ -524,9 +439,9 @@ int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, *seq_number = 0; yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block, NULL, - &spare0, &dummy, 1); - yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, NULL, - &spare1, &dummy, 1); + &spare0, &dummy, 1); + yaffs_rd_chunk_nand(dev, block_no * dev->param.chunks_per_block + 1, + NULL, &spare1, &dummy, 1); if (yaffs_count_bits(spare0.block_status & spare1.block_status) < 7) *state = YAFFS_BLOCK_STATE_DEAD; diff --git a/yaffs_tagscompat.h b/yaffs_tagscompat.h index 889bf5f..8cd35dc 100644 --- a/yaffs_tagscompat.h +++ b/yaffs_tagscompat.h @@ -17,23 +17,20 @@ #define __YAFFS_TAGSCOMPAT_H__ #include "yaffs_guts.h" -int yaffs_tags_compat_wr(yaffs_dev_t *dev, - int nand_chunk, - const __u8 *data, - const yaffs_ext_tags *tags); -int yaffs_tags_compat_rd(yaffs_dev_t *dev, - int nand_chunk, - __u8 *data, - yaffs_ext_tags *tags); -int yaffs_tags_compat_mark_bad(struct yaffs_dev_s *dev, - int block_no); -int yaffs_tags_compat_query_block(struct yaffs_dev_s *dev, - int block_no, - yaffs_block_state_t *state, - __u32 *seq_number); +int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 * data, const struct yaffs_ext_tags *tags); +int yaffs_tags_compat_rd(struct yaffs_dev *dev, + int nand_chunk, + u8 * data, struct yaffs_ext_tags *tags); +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int block_no); +int yaffs_tags_compat_query_block(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 * seq_number); -void yaffs_calc_tags_ecc(yaffs_tags_t *tags); -int yaffs_check_tags_ecc(yaffs_tags_t *tags); -int yaffs_count_bits(__u8 byte); +void yaffs_calc_tags_ecc(struct yaffs_tags *tags); +int yaffs_check_tags_ecc(struct yaffs_tags *tags); +int yaffs_count_bits(u8 byte); #endif diff --git a/yaffs_tagsvalidity.c b/yaffs_tagsvalidity.c index 787cdba..4358d79 100644 --- a/yaffs_tagsvalidity.c +++ b/yaffs_tagsvalidity.c @@ -13,16 +13,15 @@ #include "yaffs_tagsvalidity.h" -void yaffs_init_tags(yaffs_ext_tags *tags) +void yaffs_init_tags(struct yaffs_ext_tags *tags) { - memset(tags, 0, sizeof(yaffs_ext_tags)); - tags->validity1 = 0xAAAAAAAA; - tags->validty1 = 0x55555555; + memset(tags, 0, sizeof(struct yaffs_ext_tags)); + tags->validity0 = 0xAAAAAAAA; + tags->validity1 = 0x55555555; } -int yaffs_validate_tags(yaffs_ext_tags *tags) +int yaffs_validate_tags(struct yaffs_ext_tags *tags) { - return (tags->validity1 == 0xAAAAAAAA && - tags->validty1 == 0x55555555); + return (tags->validity0 == 0xAAAAAAAA && tags->validity1 == 0x55555555); } diff --git a/yaffs_tagsvalidity.h b/yaffs_tagsvalidity.h index 085056c..36a021f 100644 --- a/yaffs_tagsvalidity.h +++ b/yaffs_tagsvalidity.h @@ -13,12 +13,11 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YAFFS_TAGS_VALIDITY_H__ #define __YAFFS_TAGS_VALIDITY_H__ #include "yaffs_guts.h" -void yaffs_init_tags(yaffs_ext_tags *tags); -int yaffs_validate_tags(yaffs_ext_tags *tags); +void yaffs_init_tags(struct yaffs_ext_tags *tags); +int yaffs_validate_tags(struct yaffs_ext_tags *tags); #endif diff --git a/yaffs_trace.h b/yaffs_trace.h index 9fe7214..90dbefc 100644 --- a/yaffs_trace.h +++ b/yaffs_trace.h @@ -13,7 +13,6 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YTRACE_H__ #define __YTRACE_H__ @@ -54,7 +53,6 @@ extern unsigned int yaffs_wr_attempts; #define YAFFS_TRACE_BUG 0x80000000 #define YAFFS_TRACE_ALWAYS 0xF0000000 - #define T(mask, p) do { if ((mask) & (yaffs_trace_mask | YAFFS_TRACE_ALWAYS)) TOUT(p); } while (0) #endif diff --git a/yaffs_verify.c b/yaffs_verify.c index 89e730b..fee3a1e 100644 --- a/yaffs_verify.c +++ b/yaffs_verify.c @@ -11,47 +11,45 @@ * published by the Free Software Foundation. */ - #include "yaffs_verify.h" #include "yaffs_trace.h" #include "yaffs_bitmap.h" #include "yaffs_getblockinfo.h" #include "yaffs_nand.h" -int yaffs_skip_verification(yaffs_dev_t *dev) +int yaffs_skip_verification(struct yaffs_dev *dev) { - dev=dev; - return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); + dev = dev; + return !(yaffs_trace_mask & + (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); } -static int yaffs_skip_full_verification(yaffs_dev_t *dev) +static int yaffs_skip_full_verification(struct yaffs_dev *dev) { - dev=dev; + dev = dev; return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL)); } -static int yaffs_skip_nand_verification(yaffs_dev_t *dev) +static int yaffs_skip_nand_verification(struct yaffs_dev *dev) { - dev=dev; + dev = dev; return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND)); } - static const char *block_state_name[] = { -"Unknown", -"Needs scanning", -"Scanning", -"Empty", -"Allocating", -"Full", -"Dirty", -"Checkpoint", -"Collecting", -"Dead" + "Unknown", + "Needs scanning", + "Scanning", + "Empty", + "Allocating", + "Full", + "Dirty", + "Checkpoint", + "Collecting", + "Dead" }; - -void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n) +void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, int n) { int actually_used; int in_use; @@ -61,51 +59,60 @@ void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n) /* Report illegal runtime states */ if (bi->block_state >= YAFFS_NUMBER_OF_BLOCK_STATES) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has undefined state %d"TENDSTR), n, bi->block_state)); + T(YAFFS_TRACE_VERIFY, + (TSTR("Block %d has undefined state %d" TENDSTR), n, + bi->block_state)); switch (bi->block_state) { case YAFFS_BLOCK_STATE_UNKNOWN: case YAFFS_BLOCK_STATE_SCANNING: case YAFFS_BLOCK_STATE_NEEDS_SCANNING: - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has bad run-state %s"TENDSTR), - n, block_state_name[bi->block_state])); + T(YAFFS_TRACE_VERIFY, + (TSTR("Block %d has bad run-state %s" TENDSTR), n, + block_state_name[bi->block_state])); } /* Check pages in use and soft deletions are legal */ actually_used = bi->pages_in_use - bi->soft_del_pages; - if (bi->pages_in_use < 0 || bi->pages_in_use > dev->param.chunks_per_block || - bi->soft_del_pages < 0 || bi->soft_del_pages > dev->param.chunks_per_block || - actually_used < 0 || actually_used > dev->param.chunks_per_block) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has illegal values pages_in_used %d soft_del_pages %d"TENDSTR), - n, bi->pages_in_use, bi->soft_del_pages)); - + if (bi->pages_in_use < 0 + || bi->pages_in_use > dev->param.chunks_per_block + || bi->soft_del_pages < 0 + || bi->soft_del_pages > dev->param.chunks_per_block + || actually_used < 0 || actually_used > dev->param.chunks_per_block) + T(YAFFS_TRACE_VERIFY, + (TSTR + ("Block %d has illegal values pages_in_used %d soft_del_pages %d" + TENDSTR), n, bi->pages_in_use, bi->soft_del_pages)); /* Check chunk bitmap legal */ in_use = yaffs_count_chunk_bits(dev, n); if (in_use != bi->pages_in_use) - T(YAFFS_TRACE_VERIFY, (TSTR("Block %d has inconsistent values pages_in_use %d counted chunk bits %d"TENDSTR), - n, bi->pages_in_use, in_use)); + T(YAFFS_TRACE_VERIFY, + (TSTR + ("Block %d has inconsistent values pages_in_use %d counted chunk bits %d" + TENDSTR), n, bi->pages_in_use, in_use)); } - - -void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n) +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n) { yaffs_verify_blk(dev, bi, n); /* After collection the block should be in the erased state */ if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING && - bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { - T(YAFFS_TRACE_ERROR, (TSTR("Block %d is in state %d after gc, should be erased"TENDSTR), - n, bi->block_state)); + bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { + T(YAFFS_TRACE_ERROR, + (TSTR + ("Block %d is in state %d after gc, should be erased" + TENDSTR), n, bi->block_state)); } } -void yaffs_verify_blocks(yaffs_dev_t *dev) +void yaffs_verify_blocks(struct yaffs_dev *dev) { int i; int state_count[YAFFS_NUMBER_OF_BLOCK_STATES]; @@ -117,7 +124,7 @@ void yaffs_verify_blocks(yaffs_dev_t *dev) memset(state_count, 0, sizeof(state_count)); for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { - yaffs_block_info_t *bi = yaffs_get_block_info(dev, i); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); yaffs_verify_blk(dev, bi, i); if (bi->block_state < YAFFS_NUMBER_OF_BLOCK_STATES) @@ -126,34 +133,37 @@ void yaffs_verify_blocks(yaffs_dev_t *dev) illegal_states++; } - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); - T(YAFFS_TRACE_VERIFY, (TSTR("Block summary"TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("Block summary" TENDSTR))); - T(YAFFS_TRACE_VERIFY, (TSTR("%d blocks have illegal states"TENDSTR), illegal_states)); + T(YAFFS_TRACE_VERIFY, + (TSTR("%d blocks have illegal states" TENDSTR), illegal_states)); if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1) - T(YAFFS_TRACE_VERIFY, (TSTR("Too many allocating blocks"TENDSTR))); + T(YAFFS_TRACE_VERIFY, + (TSTR("Too many allocating blocks" TENDSTR))); for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++) T(YAFFS_TRACE_VERIFY, - (TSTR("%s %d blocks"TENDSTR), - block_state_name[i], state_count[i])); + (TSTR("%s %d blocks" TENDSTR), + block_state_name[i], state_count[i])); if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT]) T(YAFFS_TRACE_VERIFY, - (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR), - dev->blocks_in_checkpt, state_count[YAFFS_BLOCK_STATE_CHECKPOINT])); + (TSTR("Checkpoint block count wrong dev %d count %d" TENDSTR), + dev->blocks_in_checkpt, + state_count[YAFFS_BLOCK_STATE_CHECKPOINT])); if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY]) T(YAFFS_TRACE_VERIFY, - (TSTR("Erased block count wrong dev %d count %d"TENDSTR), - dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY])); + (TSTR("Erased block count wrong dev %d count %d" TENDSTR), + dev->n_erased_blocks, state_count[YAFFS_BLOCK_STATE_EMPTY])); if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1) T(YAFFS_TRACE_VERIFY, - (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR), - state_count[YAFFS_BLOCK_STATE_COLLECTING])); + (TSTR("Too many collecting blocks %d (max is 1)" TENDSTR), + state_count[YAFFS_BLOCK_STATE_COLLECTING])); - T(YAFFS_TRACE_VERIFY, (TSTR(""TENDSTR))); + T(YAFFS_TRACE_VERIFY, (TSTR("" TENDSTR))); } @@ -161,29 +171,29 @@ void yaffs_verify_blocks(yaffs_dev_t *dev) * Verify the object header. oh must be valid, but obj and tags may be NULL in which * case those tests will not be performed. */ -void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parent_check) +void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check) { if (obj && yaffs_skip_verification(obj->my_dev)) return; if (!(tags && obj && oh)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Verifying object header tags %p obj %p oh %p"TENDSTR), - tags, obj, oh)); + (TSTR("Verifying object header tags %p obj %p oh %p" TENDSTR), + tags, obj, oh)); return; } if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN || - oh->type > YAFFS_OBJECT_TYPE_MAX) + oh->type > YAFFS_OBJECT_TYPE_MAX) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR), - tags->obj_id, oh->type)); + (TSTR("Obj %d header type is illegal value 0x%x" TENDSTR), + tags->obj_id, oh->type)); if (tags->obj_id != obj->obj_id) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch obj_id %d"TENDSTR), - tags->obj_id, obj->obj_id)); - + (TSTR("Obj %d header mismatch obj_id %d" TENDSTR), + tags->obj_id, obj->obj_id)); /* * Check that the object's parent ids match if parent_check requested. @@ -193,89 +203,40 @@ void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tag if (parent_check && tags->obj_id > 1 && !obj->parent) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parent_id %d obj->parent is NULL"TENDSTR), - tags->obj_id, oh->parent_obj_id)); + (TSTR + ("Obj %d header mismatch parent_id %d obj->parent is NULL" + TENDSTR), tags->obj_id, oh->parent_obj_id)); if (parent_check && obj->parent && - oh->parent_obj_id != obj->parent->obj_id && - (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED || - obj->parent->obj_id != YAFFS_OBJECTID_DELETED)) + oh->parent_obj_id != obj->parent->obj_id && + (oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED || + obj->parent->obj_id != YAFFS_OBJECTID_DELETED)) T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parent_id %d parent_obj_id %d"TENDSTR), - tags->obj_id, oh->parent_obj_id, obj->parent->obj_id)); + (TSTR + ("Obj %d header mismatch parent_id %d parent_obj_id %d" + TENDSTR), tags->obj_id, oh->parent_obj_id, + obj->parent->obj_id)); - if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ + if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is NULL"TENDSTR), - obj->obj_id)); + (TSTR("Obj %d header name is NULL" TENDSTR), obj->obj_id)); - if (tags->obj_id > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ + if (tags->obj_id > 1 && ((u8) (oh->name[0])) == 0xff) /* Trashed name */ T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is 0xFF"TENDSTR), - obj->obj_id)); + (TSTR("Obj %d header name is 0xFF" TENDSTR), obj->obj_id)); } - -#if 0 -/* Not being used, but don't want to throw away yet */ -int yaffs_verify_tnode_worker(yaffs_obj_t *obj, yaffs_tnode_t *tn, - __u32 level, int chunk_offset) -{ - int i; - yaffs_dev_t *dev = obj->my_dev; - int ok = 1; - - if (tn) { - if (level > 0) { - - for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { - if (tn->internal[i]) { - ok = yaffs_verify_tnode_worker(obj, - tn->internal[i], - level - 1, - (chunk_offset<obj_id; - - chunk_offset <<= YAFFS_TNODES_LEVEL0_BITS; - - for (i = 0; i < YAFFS_NTNODES_LEVEL0; i++) { - __u32 the_chunk = yaffs_get_group_base(dev, tn, i); - - if (the_chunk > 0) { - /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.obj_id,tags.chunk_id,the_chunk)); */ - yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags); - if (tags.obj_id != obj_id || tags.chunk_id != chunk_offset) { - T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - obj_id, chunk_offset, the_chunk, - tags.obj_id, tags.chunk_id)); - } - } - chunk_offset++; - } - } - } - - return ok; - -} - -#endif - -void yaffs_verify_file(yaffs_obj_t *obj) +void yaffs_verify_file(struct yaffs_obj *obj) { int required_depth; int actual_depth; - __u32 last_chunk; - __u32 x; - __u32 i; - yaffs_dev_t *dev; - yaffs_ext_tags tags; - yaffs_tnode_t *tn; - __u32 obj_id; + u32 last_chunk; + u32 x; + u32 i; + struct yaffs_dev *dev; + struct yaffs_ext_tags tags; + struct yaffs_tnode *tn; + u32 obj_id; if (!obj) return; @@ -287,7 +248,8 @@ void yaffs_verify_file(yaffs_obj_t *obj) obj_id = obj->obj_id; /* Check file size is consistent with tnode depth */ - last_chunk = obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1; + last_chunk = + obj->variant.file_variant.file_size / dev->data_bytes_per_chunk + 1; x = last_chunk >> YAFFS_TNODES_LEVEL0_BITS; required_depth = 0; while (x > 0) { @@ -309,22 +271,24 @@ void yaffs_verify_file(yaffs_obj_t *obj) tn = yaffs_find_tnode_0(dev, &obj->variant.file_variant, i); if (tn) { - __u32 the_chunk = yaffs_get_group_base(dev, tn, i); + u32 the_chunk = yaffs_get_group_base(dev, tn, i); if (the_chunk > 0) { /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),obj_id,i,the_chunk)); */ - yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, &tags); + yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, + &tags); if (tags.obj_id != obj_id || tags.chunk_id != i) { - T(~0, (TSTR("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - obj_id, i, the_chunk, - tags.obj_id, tags.chunk_id)); + T(~0, + (TSTR + ("Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)" + TENDSTR), obj_id, i, the_chunk, + tags.obj_id, tags.chunk_id)); } } } } } - -void yaffs_verify_link(yaffs_obj_t *obj) +void yaffs_verify_link(struct yaffs_obj *obj) { if (obj && yaffs_skip_verification(obj->my_dev)) return; @@ -332,7 +296,7 @@ void yaffs_verify_link(yaffs_obj_t *obj) /* Verify sane equivalent object */ } -void yaffs_verify_symlink(yaffs_obj_t *obj) +void yaffs_verify_symlink(struct yaffs_obj *obj) { if (obj && yaffs_skip_verification(obj->my_dev)) return; @@ -340,23 +304,23 @@ void yaffs_verify_symlink(yaffs_obj_t *obj) /* Verify symlink string */ } -void yaffs_verify_special(yaffs_obj_t *obj) +void yaffs_verify_special(struct yaffs_obj *obj) { if (obj && yaffs_skip_verification(obj->my_dev)) return; } -void yaffs_verify_obj(yaffs_obj_t *obj) +void yaffs_verify_obj(struct yaffs_obj *obj) { - yaffs_dev_t *dev; + struct yaffs_dev *dev; - __u32 chunk_min; - __u32 chunk_max; + u32 chunk_min; + u32 chunk_max; - __u32 chunk_id_ok; - __u32 chunk_in_range; - __u32 chunk_wrongly_deleted; - __u32 chunk_valid; + u32 chunk_id_ok; + u32 chunk_in_range; + u32 chunk_wrongly_deleted; + u32 chunk_valid; if (!obj) return; @@ -372,35 +336,34 @@ void yaffs_verify_obj(yaffs_obj_t *obj) /* Check sane object header chunk */ chunk_min = dev->internal_start_block * dev->param.chunks_per_block; - chunk_max = (dev->internal_end_block+1) * dev->param.chunks_per_block - 1; + chunk_max = + (dev->internal_end_block + 1) * dev->param.chunks_per_block - 1; - chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min && - ((unsigned)(obj->hdr_chunk)) <= chunk_max); + chunk_in_range = (((unsigned)(obj->hdr_chunk)) >= chunk_min && + ((unsigned)(obj->hdr_chunk)) <= chunk_max); chunk_id_ok = chunk_in_range || (obj->hdr_chunk == 0); chunk_valid = chunk_in_range && - yaffs_check_chunk_bit(dev, - obj->hdr_chunk / dev->param.chunks_per_block, - obj->hdr_chunk % dev->param.chunks_per_block); + yaffs_check_chunk_bit(dev, + obj->hdr_chunk / dev->param.chunks_per_block, + obj->hdr_chunk % dev->param.chunks_per_block); chunk_wrongly_deleted = chunk_in_range && !chunk_valid; - if (!obj->fake && - (!chunk_id_ok || chunk_wrongly_deleted)) { + if (!obj->fake && (!chunk_id_ok || chunk_wrongly_deleted)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has chunk_id %d %s %s"TENDSTR), - obj->obj_id, obj->hdr_chunk, - chunk_id_ok ? "" : ",out of range", - chunk_wrongly_deleted ? ",marked as deleted" : "")); + (TSTR("Obj %d has chunk_id %d %s %s" TENDSTR), + obj->obj_id, obj->hdr_chunk, + chunk_id_ok ? "" : ",out of range", + chunk_wrongly_deleted ? ",marked as deleted" : "")); } if (chunk_valid && !yaffs_skip_nand_verification(dev)) { - yaffs_ext_tags tags; - yaffs_obj_header *oh; - __u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); + struct yaffs_ext_tags tags; + struct yaffs_obj_hdr *oh; + u8 *buffer = yaffs_get_temp_buffer(dev, __LINE__); - oh = (yaffs_obj_header *)buffer; + oh = (struct yaffs_obj_hdr *)buffer; - yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, - &tags); + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, buffer, &tags); yaffs_verify_oh(obj, oh, &tags, 1); @@ -408,18 +371,19 @@ void yaffs_verify_obj(yaffs_obj_t *obj) } /* Verify it has a parent */ - if (obj && !obj->fake && - (!obj->parent || obj->parent->my_dev != dev)) { + if (obj && !obj->fake && (!obj->parent || obj->parent->my_dev != dev)) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR), - obj->obj_id, obj->parent)); + (TSTR + ("Obj %d has parent pointer %p which does not look like an object" + TENDSTR), obj->obj_id, obj->parent)); } /* Verify parent is a directory */ - if (obj->parent && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + if (obj->parent + && obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR), - obj->obj_id, obj->parent->variant_type)); + (TSTR("Obj %d's parent is not a directory (type %d)" TENDSTR), + obj->obj_id, obj->parent->variant_type)); } switch (obj->variant_type) { @@ -441,38 +405,38 @@ void yaffs_verify_obj(yaffs_obj_t *obj) case YAFFS_OBJECT_TYPE_UNKNOWN: default: T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has illegaltype %d"TENDSTR), - obj->obj_id, obj->variant_type)); + (TSTR("Obj %d has illegaltype %d" TENDSTR), + obj->obj_id, obj->variant_type)); break; } } -void yaffs_verify_objects(yaffs_dev_t *dev) +void yaffs_verify_objects(struct yaffs_dev *dev) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int i; - struct ylist_head *lh; + struct list_head *lh; if (yaffs_skip_verification(dev)) return; /* Iterate through the objects in each hash entry */ - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->obj_bucket[i].list) { + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_obj_t, hash_link); + obj = + list_entry(lh, struct yaffs_obj, hash_link); yaffs_verify_obj(obj); } } } } - -void yaffs_verify_obj_in_dir(yaffs_obj_t *obj) +void yaffs_verify_obj_in_dir(struct yaffs_obj *obj) { - struct ylist_head *lh; - yaffs_obj_t *list_obj; + struct list_head *lh; + struct yaffs_obj *list_obj; int count = 0; @@ -486,37 +450,40 @@ void yaffs_verify_obj_in_dir(yaffs_obj_t *obj) return; if (!obj->parent) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Object does not have parent" TENDSTR))); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Object does not have parent" TENDSTR))); YBUG(); return; } if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Parent is not directory" TENDSTR))); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Parent is not directory" TENDSTR))); YBUG(); } /* Iterate through the objects in each hash entry */ - ylist_for_each(lh, &obj->parent->variant.dir_variant.children) { + list_for_each(lh, &obj->parent->variant.dir_variant.children) { if (lh) { - list_obj = ylist_entry(lh, yaffs_obj_t, siblings); + list_obj = list_entry(lh, struct yaffs_obj, siblings); yaffs_verify_obj(list_obj); if (obj == list_obj) count++; } - } + } if (count != 1) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Object in directory %d times" TENDSTR), count)); + T(YAFFS_TRACE_ALWAYS, + (TSTR("Object in directory %d times" TENDSTR), count)); YBUG(); } } -void yaffs_verify_dir(yaffs_obj_t *directory) +void yaffs_verify_dir(struct yaffs_obj *directory) { - struct ylist_head *lh; - yaffs_obj_t *list_obj; + struct list_head *lh; + struct yaffs_obj *list_obj; if (!directory) { YBUG(); @@ -528,20 +495,21 @@ void yaffs_verify_dir(yaffs_obj_t *directory) if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { T(YAFFS_TRACE_ALWAYS, - (TSTR("Directory has wrong type: %d" TENDSTR), - directory->variant_type)); + (TSTR("Directory has wrong type: %d" TENDSTR), + directory->variant_type)); YBUG(); } /* Iterate through the objects in each hash entry */ - ylist_for_each(lh, &directory->variant.dir_variant.children) { + list_for_each(lh, &directory->variant.dir_variant.children) { if (lh) { - list_obj = ylist_entry(lh, yaffs_obj_t, siblings); + list_obj = list_entry(lh, struct yaffs_obj, siblings); if (list_obj->parent != directory) { - T(YAFFS_TRACE_ALWAYS, ( - TSTR("Object in directory list has wrong parent %p" TENDSTR), - list_obj->parent)); + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("Object in directory list has wrong parent %p" + TENDSTR), list_obj->parent)); YBUG(); } yaffs_verify_obj_in_dir(list_obj); @@ -551,7 +519,7 @@ void yaffs_verify_dir(yaffs_obj_t *directory) static int yaffs_free_verification_failures; -void yaffs_verify_free_chunks(yaffs_dev_t *dev) +void yaffs_verify_free_chunks(struct yaffs_dev *dev) { int counted; int difference; @@ -571,61 +539,8 @@ void yaffs_verify_free_chunks(yaffs_dev_t *dev) } } -int yaffs_verify_file_sane(yaffs_obj_t *in) +int yaffs_verify_file_sane(struct yaffs_obj *in) { -#if 0 - int chunk; - int n_chunks; - int file_size; - int failed = 0; - int obj_id; - yaffs_tnode_t *tn; - yaffs_tags_t local_tags; - yaffs_tags_t *tags = &local_tags; - int the_chunk; - int is_deleted; - - if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) - return YAFFS_FAIL; - - obj_id = in->obj_id; - file_size = in->variant.file_variant.file_size; - n_chunks = - (file_size + in->my_dev->data_bytes_per_chunk - 1) / in->my_dev->data_bytes_per_chunk; - - for (chunk = 1; chunk <= n_chunks; chunk++) { - tn = yaffs_find_tnode_0(in->my_dev, &in->variant.file_variant, - chunk); - - if (tn) { - - the_chunk = yaffs_get_group_base(dev, tn, chunk); - - if (yaffs_check_chunk_bits - (dev, the_chunk / dev->param.chunks_per_block, - the_chunk % dev->param.chunks_per_block)) { - - yaffs_rd_chunk_tags_nand(in->my_dev, the_chunk, - tags, - &is_deleted); - if (yaffs_tags_match - (tags, in->obj_id, chunk, is_deleted)) { - /* found it; */ - - } - } else { - - failed = 1; - } - - } else { - /* T(("No level 0 found for %d\n", chunk)); */ - } - } - - return failed ? YAFFS_FAIL : YAFFS_OK; -#else - in=in; + in = in; return YAFFS_OK; -#endif } diff --git a/yaffs_verify.h b/yaffs_verify.h index 6118afd..cc6f889 100644 --- a/yaffs_verify.h +++ b/yaffs_verify.h @@ -18,24 +18,26 @@ #include "yaffs_guts.h" -void yaffs_verify_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n); -void yaffs_verify_collected_blk(yaffs_dev_t *dev, yaffs_block_info_t *bi, int n); -void yaffs_verify_blocks(yaffs_dev_t *dev); - -void yaffs_verify_oh(yaffs_obj_t *obj, yaffs_obj_header *oh, yaffs_ext_tags *tags, int parent_check); -void yaffs_verify_file(yaffs_obj_t *obj); -void yaffs_verify_link(yaffs_obj_t *obj); -void yaffs_verify_symlink(yaffs_obj_t *obj); -void yaffs_verify_special(yaffs_obj_t *obj); -void yaffs_verify_obj(yaffs_obj_t *obj); -void yaffs_verify_objects(yaffs_dev_t *dev); -void yaffs_verify_obj_in_dir(yaffs_obj_t *obj); -void yaffs_verify_dir(yaffs_obj_t *directory); -void yaffs_verify_free_chunks(yaffs_dev_t *dev); - -int yaffs_verify_file_sane(yaffs_obj_t *obj); - -int yaffs_skip_verification(yaffs_dev_t *dev); +void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, + int n); +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n); +void yaffs_verify_blocks(struct yaffs_dev *dev); + +void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check); +void yaffs_verify_file(struct yaffs_obj *obj); +void yaffs_verify_link(struct yaffs_obj *obj); +void yaffs_verify_symlink(struct yaffs_obj *obj); +void yaffs_verify_special(struct yaffs_obj *obj); +void yaffs_verify_obj(struct yaffs_obj *obj); +void yaffs_verify_objects(struct yaffs_dev *dev); +void yaffs_verify_obj_in_dir(struct yaffs_obj *obj); +void yaffs_verify_dir(struct yaffs_obj *directory); +void yaffs_verify_free_chunks(struct yaffs_dev *dev); + +int yaffs_verify_file_sane(struct yaffs_obj *obj); + +int yaffs_skip_verification(struct yaffs_dev *dev); #endif - diff --git a/yaffs_vfs_multi.c b/yaffs_vfs_multi.c index 3bd5aea..9e4e31a 100644 --- a/yaffs_vfs_multi.c +++ b/yaffs_vfs_multi.c @@ -24,11 +24,11 @@ * the VFS. * * Special notes: - * >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with + * >> 2.4: sb->u.generic_sbp points to the struct yaffs_dev associated with * this superblock - * >> 2.6: sb->s_fs_info points to the yaffs_dev_t associated with this + * >> 2.6: sb->s_fs_info points to the struct yaffs_dev associated with this * superblock - * >> inode->u.generic_ip points to the associated yaffs_obj_t. + * >> inode->u.generic_ip points to the associated struct yaffs_obj. */ /* @@ -151,7 +151,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) { uint64_t result = partition_size; do_div(result, block_size); - return (uint32_t)result; + return (uint32_t) result; } #else #define YCALCBLOCKS(s, b) ((s)/(b)) @@ -163,6 +163,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) #include "yportenv.h" #include "yaffs_trace.h" #include "yaffs_guts.h" +#include "yaffs_attribs.h" #include "yaffs_linux.h" @@ -209,24 +210,23 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino); #define yaffs_inode_to_obj_lv(iptr) ((iptr)->u.generic_ip) #endif -#define yaffs_inode_to_obj(iptr) ((yaffs_obj_t *)(yaffs_inode_to_obj_lv(iptr))) +#define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr))) #define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode) #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) -#define yaffs_super_to_dev(sb) ((yaffs_dev_t *)sb->s_fs_info) +#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info) #else -#define yaffs_super_to_dev(sb) ((yaffs_dev_t *)sb->u.generic_sbp) +#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->u.generic_sbp) #endif - #define update_dir_time(dir) do {\ (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \ } while(0) - + static void yaffs_put_super(struct super_block *sb); static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos); + loff_t * pos); static ssize_t yaffs_hold_space(struct file *f); static void yaffs_release_space(struct file *f); @@ -240,7 +240,7 @@ static int yaffs_file_flush(struct file *file); static int yaffs_sync_object(struct file *file, int datasync); #else static int yaffs_sync_object(struct file *file, struct dentry *dentry, - int datasync); + int datasync); #endif static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); @@ -249,24 +249,24 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n); + struct nameidata *n); #else static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry); #endif static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry); + struct dentry *dentry); static int yaffs_unlink(struct inode *dir, struct dentry *dentry); static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname); + const char *symname); static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t dev); + dev_t dev); #else static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - int dev); + int dev); #endif static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry); @@ -308,31 +308,30 @@ static int yaffs_writepage(struct page *page); #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags); + const void *value, size_t size, int flags); ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size); + size_t size); int yaffs_removexattr(struct dentry *dentry, const char *name); ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size); #endif - #if (YAFFS_USE_WRITE_BEGIN_END != 0) static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata); + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata); static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata); + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata); #else static int yaffs_prepare_write(struct file *f, struct page *pg, - unsigned offset, unsigned to); + unsigned offset, unsigned to); static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, - unsigned to); + unsigned to); #endif -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen); +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen); #if (YAFFS_NEW_FOLLOW_LINK == 1) void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias); static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); @@ -340,13 +339,12 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); #endif -static void yaffs_touch_super(yaffs_dev_t *dev); +static void yaffs_touch_super(struct yaffs_dev *dev); static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); static int yaffs_vfs_setattr(struct inode *, struct iattr *); - static struct address_space_operations yaffs_file_address_operations = { .readpage = yaffs_readpage, .writepage = yaffs_writepage, @@ -359,7 +357,6 @@ static struct address_space_operations yaffs_file_address_operations = { #endif }; - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)) static const struct file_operations yaffs_file_operations = { .read = do_sync_read, @@ -404,14 +401,13 @@ static const struct file_operations yaffs_file_operations = { #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25)) static void zero_user_segment(struct page *page, unsigned start, unsigned end) { - void * kaddr = kmap_atomic(page, KM_USER0); + void *kaddr = kmap_atomic(page, KM_USER0); memset(kaddr + start, 0, end - start); kunmap_atomic(kaddr, KM_USER0); flush_dcache_page(page); } #endif - static const struct inode_operations yaffs_file_inode_operations = { .setattr = yaffs_setattr, #ifdef CONFIG_YAFFS_XATTR @@ -483,11 +479,10 @@ static const struct super_operations yaffs_super_ops = { .write_super = yaffs_write_super, }; - -static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) +static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) { #ifdef YAFFS_USE_SETATTR_COPY - setattr_copy(inode,attr); + setattr_copy(inode, attr); return 0; #else return inode_setattr(inode, attr); @@ -495,54 +490,58 @@ static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) } -static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) +static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) { #ifdef YAFFS_USE_TRUNCATE_SETSIZE - truncate_setsize(inode,newsize); + truncate_setsize(inode, newsize); return 0; #else - truncate_inode_pages(&inode->i_data,newsize); + truncate_inode_pages(&inode->i_data, newsize); return 0; #endif } -static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev) +static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev) { return yaffs_gc_control; } - -static void yaffs_gross_lock(yaffs_dev_t *dev) + +static void yaffs_gross_lock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); - down(&(yaffs_dev_to_lc(dev)->gross_lock)); + mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock)); T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current)); } -static void yaffs_gross_unlock(yaffs_dev_t *dev) +static void yaffs_gross_unlock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current)); - up(&(yaffs_dev_to_lc(dev)->gross_lock)); + mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock)); } #ifdef YAFFS_COMPILE_EXPORTFS -static struct inode * -yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation) +static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, + uint32_t generation) { return Y_IGET(sb, ino); } -static struct dentry * -yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ; + return generic_fh_to_dentry(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } -static struct dentry * - yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_parent(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode); + return generic_fh_to_parent(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } struct dentry *yaffs2_get_parent(struct dentry *dentry) @@ -552,8 +551,8 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) struct dentry *parent = ERR_PTR(-ENOENT); struct inode *inode; unsigned long parent_ino; - yaffs_obj_t *d_obj; - yaffs_obj_t *parent_obj; + struct yaffs_obj *d_obj; + struct yaffs_obj *parent_obj; d_obj = yaffs_inode_to_obj(dentry->d_inode); @@ -582,12 +581,11 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) * using the default functions of exportfs. */ -static struct export_operations yaffs_export_ops = -{ +static struct export_operations yaffs_export_ops = { .fh_to_dentry = yaffs2_fh_to_dentry, .fh_to_parent = yaffs2_fh_to_parent, .get_parent = yaffs2_get_parent, -} ; +}; #endif @@ -603,7 +601,7 @@ static struct export_operations yaffs_export_ops = * next object before the object is deleted. * * Many readdirs (and thus seach conexts) may be alive simulateously so - * each yaffs_dev_t has a list of these. + * each struct yaffs_dev has a list of these. * * A seach context lives for the duration of a readdir. * @@ -611,10 +609,10 @@ static struct export_operations yaffs_export_ops = */ struct yaffs_search_context { - yaffs_dev_t *dev; - yaffs_obj_t *dir_obj; - yaffs_obj_t *next_return; - struct ylist_head others; + struct yaffs_dev *dev; + struct yaffs_obj *dir_obj; + struct yaffs_obj *next_return; + struct list_head others; }; /* @@ -623,21 +621,22 @@ struct yaffs_search_context { * * Called at start of readdir. */ -static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir) +static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir) { - yaffs_dev_t *dev = dir->my_dev; - struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context)); - if(sc){ + struct yaffs_dev *dev = dir->my_dev; + struct yaffs_search_context *sc = + YMALLOC(sizeof(struct yaffs_search_context)); + if (sc) { sc->dir_obj = dir; sc->dev = dev; - if( ylist_empty(&sc->dir_obj->variant.dir_variant.children)) + if (list_empty(&sc->dir_obj->variant.dir_variant.children)) sc->next_return = NULL; else - sc->next_return = ylist_entry( - dir->variant.dir_variant.children.next, - yaffs_obj_t,siblings); - YINIT_LIST_HEAD(&sc->others); - ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts)); + sc->next_return = + list_entry(dir->variant.dir_variant.children.next, + struct yaffs_obj, siblings); + INIT_LIST_HEAD(&sc->others); + list_add(&sc->others, &(yaffs_dev_to_lc(dev)->search_contexts)); } return sc; } @@ -645,10 +644,10 @@ static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir) /* * yaffs_search_end() disposes of a search context and cleans up. */ -static void yaffs_search_end(struct yaffs_search_context * sc) +static void yaffs_search_end(struct yaffs_search_context *sc) { - if(sc){ - ylist_del(&sc->others); + if (sc) { + list_del(&sc->others); YFREE(sc); } } @@ -660,20 +659,21 @@ static void yaffs_search_end(struct yaffs_search_context * sc) */ static void yaffs_search_advance(struct yaffs_search_context *sc) { - if(!sc) - return; + if (!sc) + return; - if( sc->next_return == NULL || - ylist_empty(&sc->dir_obj->variant.dir_variant.children)) - sc->next_return = NULL; - else { - struct ylist_head *next = sc->next_return->siblings.next; + if (sc->next_return == NULL || + list_empty(&sc->dir_obj->variant.dir_variant.children)) + sc->next_return = NULL; + else { + struct list_head *next = sc->next_return->siblings.next; - if( next == &sc->dir_obj->variant.dir_variant.children) - sc->next_return = NULL; /* end of list */ - else - sc->next_return = ylist_entry(next,yaffs_obj_t,siblings); - } + if (next == &sc->dir_obj->variant.dir_variant.children) + sc->next_return = NULL; /* end of list */ + else + sc->next_return = + list_entry(next, struct yaffs_obj, siblings); + } } /* @@ -681,38 +681,37 @@ static void yaffs_search_advance(struct yaffs_search_context *sc) * We check open search contexts and advance any which are currently * on the object being iterated. */ -static void yaffs_remove_obj_callback(yaffs_obj_t *obj) +static void yaffs_remove_obj_callback(struct yaffs_obj *obj) { - struct ylist_head *i; - struct yaffs_search_context *sc; - struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - + struct list_head *i; + struct yaffs_search_context *sc; + struct list_head *search_contexts = + &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - /* Iterate through the directory search contexts. - * If any are currently on the object being removed, then advance - * the search context to the next object to prevent a hanging pointer. - */ - ylist_for_each(i, search_contexts) { - if (i) { - sc = ylist_entry(i, struct yaffs_search_context,others); - if(sc->next_return == obj) - yaffs_search_advance(sc); - } + /* Iterate through the directory search contexts. + * If any are currently on the object being removed, then advance + * the search context to the next object to prevent a hanging pointer. + */ + list_for_each(i, search_contexts) { + if (i) { + sc = list_entry(i, struct yaffs_search_context, others); + if (sc->next_return == obj) + yaffs_search_advance(sc); + } } } - /*-----------------------------------------------------------------*/ -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen) +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen) { unsigned char *alias; int ret; - yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -739,7 +738,7 @@ static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) #endif unsigned char *alias; int ret_int = 0; - yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -750,32 +749,32 @@ static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) ret_int = -ENOMEM; goto out; } - #if (YAFFS_NEW_FOLLOW_LINK == 1) nd_set_link(nd, alias); ret = alias; out: - if(ret_int) + if (ret_int) ret = ERR_PTR(ret_int); return ret; #else ret = vfs_follow_link(nd, alias); kfree(alias); out: - if(ret_int) + if (ret_int) ret = ret_int; return ret; #endif } #if (YAFFS_NEW_FOLLOW_LINK == 1) -void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) { +void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) +{ kfree(alias); } #endif struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_obj_t *obj); + struct yaffs_obj *obj); /* * Lookup is used to find objects in the fs @@ -783,41 +782,39 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n) + struct nameidata *n) #else static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) #endif { - yaffs_obj_t *obj; + struct yaffs_obj *obj; struct inode *inode = NULL; /* NCB 2.5/2.6 needs NULL here */ - yaffs_dev_t *dev = yaffs_inode_to_obj(dir)->my_dev; + struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev; - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup for %d:%s\n"), - yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); + (TSTR("yaffs_lookup for %d:%s\n"), + yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); - obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), - dentry->d_name.name); + obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name); obj = yaffs_get_equivalent_obj(obj); /* in case it was a hardlink */ /* Can't hold gross lock when calling yaffs_get_inode() */ - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_unlock(dev); if (obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); + (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); if (inode) { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_loookup dentry \n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n"))); /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to * d_add even if NULL inode */ #if 0 @@ -830,7 +827,7 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) } } else { - T(YAFFS_TRACE_OS,(TSTR("yaffs_lookup not found\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n"))); } @@ -841,7 +838,6 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) return NULL; } - #ifdef YAFFS_HAS_PUT_INODE /* For now put inode is just for debugging @@ -850,17 +846,16 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry) static void yaffs_put_inode(struct inode *inode) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, - atomic_read(&inode->i_count))); + (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, + atomic_read(&inode->i_count))); } #endif - -static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj) +static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj) { /* Clear the association between the inode and - * the yaffs_obj_t. + * the struct yaffs_obj. */ obj->my_inode = NULL; yaffs_inode_to_obj_lv(inode) = NULL; @@ -877,25 +872,25 @@ static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj) * yaffs_clear_inode() and yaffs_delete_inode() * */ -static void yaffs_evict_inode( struct inode *inode) +static void yaffs_evict_inode(struct inode *inode) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; int deleteme = 0; obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (!inode->i_nlink && !is_bad_inode(inode)) deleteme = 1; - truncate_inode_pages(&inode->i_data,0); + truncate_inode_pages(&inode->i_data, 0); end_writeback(inode); - if(deleteme && obj){ + if (deleteme && obj) { dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_del_obj(obj); @@ -904,11 +899,10 @@ static void yaffs_evict_inode( struct inode *inode) if (obj) { dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_unstitch_obj(inode,obj); + yaffs_unstitch_obj(inode, obj); yaffs_gross_unlock(dev); } - } #else @@ -921,20 +915,20 @@ static void yaffs_evict_inode( struct inode *inode) static void yaffs_clear_inode(struct inode *inode) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_clear_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (obj) { dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_unstitch_obj(inode,obj); + yaffs_unstitch_obj(inode, obj); yaffs_gross_unlock(dev); } @@ -947,13 +941,13 @@ static void yaffs_clear_inode(struct inode *inode) */ static void yaffs_delete_inode(struct inode *inode) { - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); - yaffs_dev_t *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_delete_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (obj) { dev = obj->my_dev; @@ -968,20 +962,19 @@ static void yaffs_delete_inode(struct inode *inode) } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_file_flush(struct file *file, fl_owner_t id) #else static int yaffs_file_flush(struct file *file) #endif { - yaffs_obj_t *obj = yaffs_dentry_to_obj(file->f_dentry); + struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry); - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, - obj->dirty ? "dirty" : "clean")); + (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, + obj->dirty ? "dirty" : "clean")); yaffs_gross_lock(dev); @@ -996,16 +989,16 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) { /* Lifted from jffs2 */ - yaffs_obj_t *obj; + struct yaffs_obj *obj; unsigned char *pg_buf; int ret; - yaffs_dev_t *dev; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), - (unsigned)(pg->index << PAGE_CACHE_SHIFT), - (unsigned)PAGE_CACHE_SIZE)); + (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), + (unsigned)(pg->index << PAGE_CACHE_SHIFT), + (unsigned)PAGE_CACHE_SIZE)); obj = yaffs_dentry_to_obj(f->f_dentry); @@ -1024,8 +1017,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) yaffs_gross_lock(dev); ret = yaffs_file_rd(obj, pg_buf, - pg->index << PAGE_CACHE_SHIFT, - PAGE_CACHE_SIZE); + pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE); yaffs_gross_unlock(dev); @@ -1059,7 +1051,7 @@ static int yaffs_readpage(struct file *f, struct page *pg) int ret; T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n"))); - ret=yaffs_readpage_unlock(f, pg); + ret = yaffs_readpage_unlock(f, pg); T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n"))); return ret; } @@ -1072,12 +1064,12 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) static int yaffs_writepage(struct page *page) #endif { - yaffs_dev_t *dev; + struct yaffs_dev *dev; struct address_space *mapping = page->mapping; struct inode *inode; unsigned long end_index; char *buffer; - yaffs_obj_t *obj; + struct yaffs_obj *obj; int n_written = 0; unsigned n_bytes; loff_t i_size; @@ -1091,20 +1083,21 @@ static int yaffs_writepage(struct page *page) end_index = i_size >> PAGE_CACHE_SHIFT; - if(page->index < end_index) + if (page->index < end_index) n_bytes = PAGE_CACHE_SIZE; else { - n_bytes = i_size & (PAGE_CACHE_SIZE -1); + n_bytes = i_size & (PAGE_CACHE_SIZE - 1); if (page->index > end_index || !n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), - (unsigned)inode->i_size)); + (TSTR + ("yaffs_writepage at %08x, inode size = %08x!!!\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), + (unsigned)inode->i_size)); T(YAFFS_TRACE_OS, - (TSTR(" -> don't care!!\n"))); + (TSTR(" -> don't care!!\n"))); - zero_user_segment(page,0,PAGE_CACHE_SIZE); + zero_user_segment(page, 0, PAGE_CACHE_SIZE); set_page_writeback(page); unlock_page(page); end_page_writeback(page); @@ -1112,8 +1105,8 @@ static int yaffs_writepage(struct page *page) } } - if(n_bytes != PAGE_CACHE_SIZE) - zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE); + if (n_bytes != PAGE_CACHE_SIZE) + zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE); get_page(page); @@ -1124,20 +1117,20 @@ static int yaffs_writepage(struct page *page) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, size %08x\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); + (TSTR("yaffs_writepage at %08x, size %08x\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); T(YAFFS_TRACE_OS, - (TSTR("writepag0: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag0: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); n_written = yaffs_wr_file(obj, buffer, - page->index << PAGE_CACHE_SHIFT, n_bytes, 0); + page->index << PAGE_CACHE_SHIFT, n_bytes, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("writepag1: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag1: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); yaffs_gross_unlock(dev); @@ -1150,11 +1143,10 @@ static int yaffs_writepage(struct page *page) return (n_written == n_bytes) ? 0 : -ENOSPC; } - #if (YAFFS_USE_WRITE_BEGIN_END > 0) static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata) + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata) { struct page *pg = NULL; pgoff_t index = pos >> PAGE_CACHE_SHIFT; @@ -1171,12 +1163,12 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, *pagep = pg; if (!pg) { - ret = -ENOMEM; + ret = -ENOMEM; goto out; } T(YAFFS_TRACE_OS, - (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), - (int)index,(int)index,Page_Uptodate(pg) ? 1 : 0)); + (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), + (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0)); /* Get fs space */ space_held = yaffs_hold_space(filp); @@ -1201,7 +1193,7 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, out: T(YAFFS_TRACE_OS, - (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); + (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); if (space_held) yaffs_release_space(filp); if (pg) { @@ -1214,7 +1206,7 @@ out: #else static int yaffs_prepare_write(struct file *f, struct page *pg, - unsigned offset, unsigned to) + unsigned offset, unsigned to) { T(YAFFS_TRACE_OS, (TSTR("yaffs_prepair_write\n"))); @@ -1226,8 +1218,8 @@ static int yaffs_prepare_write(struct file *f, struct page *pg, #if (YAFFS_USE_WRITE_BEGIN_END > 0) static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata) + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata) { int ret = 0; void *addr, *kva; @@ -1237,15 +1229,15 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, addr = kva + offset_into_page; T(YAFFS_TRACE_OS, - ("yaffs_write_end addr %p pos %x n_bytes %d\n", - addr,(unsigned)pos, copied)); + ("yaffs_write_end addr %p pos %x n_bytes %d\n", + addr, (unsigned)pos, copied)); ret = yaffs_file_write(filp, addr, copied, &pos); if (ret != copied) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_write_end not same size ret %d copied %d\n"), - ret, copied)); + (TSTR("yaffs_write_end not same size ret %d copied %d\n"), + ret, copied)); SetPageError(pg); } else { /* Nothing */ @@ -1261,7 +1253,7 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, #else static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, - unsigned to) + unsigned to) { void *addr, *kva; @@ -1275,18 +1267,19 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, kva = kmap(pg); addr = kva + offset; - saddr = (unsigned) addr; + saddr = (unsigned)addr; T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"), - saddr, spos, n_bytes)); + (TSTR("yaffs_commit_write addr %x pos %x n_bytes %d\n"), + saddr, spos, n_bytes)); n_written = yaffs_file_write(f, addr, n_bytes, &pos); if (n_written != n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write not same size n_written %d n_bytes %d\n"), - n_written, n_bytes)); + (TSTR + ("yaffs_commit_write not same size n_written %d n_bytes %d\n"), + n_written, n_bytes)); SetPageError(pg); } else { /* Nothing */ @@ -1295,21 +1288,20 @@ static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset, kunmap(pg); T(YAFFS_TRACE_OS, - (TSTR("yaffs_commit_write returning %d\n"), - n_written == n_bytes ? 0 : n_written)); + (TSTR("yaffs_commit_write returning %d\n"), + n_written == n_bytes ? 0 : n_written)); return n_written == n_bytes ? 0 : n_written; } #endif - -static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) +static void yaffs_fill_inode_from_obj(struct inode *inode, + struct yaffs_obj *obj) { if (inode && obj) { - /* Check mode against the variant type and attempt to repair if broken. */ - __u32 mode = obj->yst_mode; + u32 mode = obj->yst_mode; switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: if (!S_ISREG(mode)) { @@ -1370,25 +1362,26 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) inode->i_nlink = yaffs_get_obj_link_count(obj); T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), - inode->i_mode, inode->i_uid, inode->i_gid, - (int)inode->i_size, atomic_read(&inode->i_count))); + (TSTR + ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), + inode->i_mode, inode->i_uid, inode->i_gid, + (int)inode->i_size, atomic_read(&inode->i_count))); switch (obj->yst_mode & S_IFMT) { default: /* fifo, device or socket */ #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) init_special_inode(inode, obj->yst_mode, - old_decode_dev(obj->yst_rdev)); + old_decode_dev(obj->yst_rdev)); #else init_special_inode(inode, obj->yst_mode, - (dev_t) (obj->yst_rdev)); + (dev_t) (obj->yst_rdev)); #endif break; case S_IFREG: /* file */ inode->i_op = &yaffs_file_inode_operations; inode->i_fop = &yaffs_file_operations; inode->i_mapping->a_ops = - &yaffs_file_address_operations; + &yaffs_file_address_operations; break; case S_IFDIR: /* directory */ inode->i_op = &yaffs_dir_inode_operations; @@ -1405,32 +1398,32 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode invalid parameters\n"))); + (TSTR("yaffs_fill_inode invalid parameters\n"))); } } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_obj_t *obj) + struct yaffs_obj *obj) { struct inode *inode; if (!sb) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL super_block!!\n"))); + (TSTR("yaffs_get_inode for NULL super_block!!\n"))); return NULL; } if (!obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL object!!\n"))); + (TSTR("yaffs_get_inode for NULL object!!\n"))); return NULL; } T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); + (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); inode = Y_IGET(sb, obj->obj_id); if (IS_ERR(inode)) @@ -1444,12 +1437,12 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, } static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos) + loff_t * pos) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int n_written, ipos; struct inode *inode; - yaffs_dev_t *dev; + struct yaffs_dev *dev; obj = yaffs_dentry_to_obj(f->f_dentry); @@ -1466,20 +1459,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, if (!obj) T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: hey obj is null!\n"))); + (TSTR("yaffs_file_write: hey obj is null!\n"))); else T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write about to write writing %u(%x) bytes" + (TSTR("yaffs_file_write about to write writing %u(%x) bytes" "to object %d at %d(%x)\n"), - (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos)); + (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos)); n_written = yaffs_wr_file(obj, buf, ipos, n, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: %d(%x) bytes written\n"), - (unsigned )n,(unsigned)n)); + (TSTR("yaffs_file_write: %d(%x) bytes written\n"), + (unsigned)n, (unsigned)n)); if (n_written > 0) { ipos += n_written; @@ -1489,9 +1482,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, inode->i_blocks = (ipos + 511) >> 9; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write size updated to %d bytes, " - "%d blocks\n"), - ipos, (int)(inode->i_blocks))); + (TSTR("yaffs_file_write size updated to %d bytes, " + "%d blocks\n"), ipos, (int)(inode->i_blocks))); } } @@ -1505,12 +1497,11 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, static ssize_t yaffs_hold_space(struct file *f) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; int n_free_chunks; - obj = yaffs_dentry_to_obj(f->f_dentry); dev = obj->my_dev; @@ -1526,9 +1517,8 @@ static ssize_t yaffs_hold_space(struct file *f) static void yaffs_release_space(struct file *f) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; - + struct yaffs_obj *obj; + struct yaffs_dev *dev; obj = yaffs_dentry_to_obj(f->f_dentry); @@ -1536,18 +1526,16 @@ static void yaffs_release_space(struct file *f) yaffs_gross_lock(dev); - yaffs_gross_unlock(dev); } - static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) { long long retval; lock_kernel(); - switch (origin){ + switch (origin) { case 2: offset += i_size_read(file->f_path.dentry->d_inode); break; @@ -1556,7 +1544,7 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) } retval = -EINVAL; - if (offset >= 0){ + if (offset >= 0) { if (offset != file->f_pos) file->f_pos = offset; @@ -1566,16 +1554,15 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) return retval; } - static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; - struct yaffs_search_context *sc; + struct yaffs_obj *obj; + struct yaffs_dev *dev; + struct yaffs_search_context *sc; struct inode *inode = f->f_dentry->d_inode; unsigned long offset, curoffs; - yaffs_obj_t *l; - int ret_val = 0; + struct yaffs_obj *l; + int ret_val = 0; char name[YAFFS_MAX_NAME_LENGTH + 1]; @@ -1588,20 +1575,21 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) offset = f->f_pos; - sc = yaffs_new_search(obj); - if(!sc){ - ret_val = -ENOMEM; - goto out; - } + sc = yaffs_new_search(obj); + if (!sc) { + ret_val = -ENOMEM; + goto out; + } - T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); if (offset == 0) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry . ino %d \n"), - (int)inode->i_ino)); + (TSTR("yaffs_readdir: entry . ino %d \n"), + (int)inode->i_ino)); yaffs_gross_unlock(dev); - if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){ + if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1611,11 +1599,12 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) } if (offset == 1) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry .. ino %d \n"), - (int)f->f_dentry->d_parent->d_inode->i_ino)); + (TSTR("yaffs_readdir: entry .. ino %d \n"), + (int)f->f_dentry->d_parent->d_inode->i_ino)); yaffs_gross_unlock(dev); if (filldir(dirent, "..", 2, offset, - f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){ + f->f_dentry->d_parent->d_inode->i_ino, + DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1634,37 +1623,34 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) f->f_version = inode->i_version; } - while(sc->next_return){ + while (sc->next_return) { curoffs++; - l = sc->next_return; + l = sc->next_return; if (curoffs >= offset) { - int this_inode = yaffs_get_obj_inode(l); - int this_type = yaffs_get_obj_type(l); + int this_inode = yaffs_get_obj_inode(l); + int this_type = yaffs_get_obj_type(l); - yaffs_get_obj_name(l, name, - YAFFS_MAX_NAME_LENGTH + 1); + yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1); T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: %s inode %d\n"), - name, yaffs_get_obj_inode(l))); + name, yaffs_get_obj_inode(l))); - yaffs_gross_unlock(dev); + yaffs_gross_unlock(dev); if (filldir(dirent, - name, - strlen(name), - offset, - this_inode, - this_type) < 0){ + name, + strlen(name), + offset, this_inode, this_type) < 0) { yaffs_gross_lock(dev); goto out; } - yaffs_gross_lock(dev); + yaffs_gross_lock(dev); offset++; f->f_pos++; } - yaffs_search_advance(sc); + yaffs_search_advance(sc); } out: @@ -1675,8 +1661,6 @@ out: return ret_val; } - - /* * File creation. Allocate an inode, and we're done.. */ @@ -1689,39 +1673,40 @@ out: #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t rdev) + dev_t rdev) #else static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - int rdev) + int rdev) #endif { struct inode *inode; - yaffs_obj_t *obj = NULL; - yaffs_dev_t *dev; + struct yaffs_obj *obj = NULL; + struct yaffs_dev *dev; - yaffs_obj_t *parent = yaffs_inode_to_obj(dir); + struct yaffs_obj *parent = yaffs_inode_to_obj(dir); int error = -ENOSPC; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; if ((dir->i_mode & S_ISGID) && S_ISDIR(mode)) mode |= S_ISGID; if (parent) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: parent object %d type %d\n"), - parent->obj_id, parent->variant_type)); + (TSTR("yaffs_mknod: parent object %d type %d\n"), + parent->obj_id, parent->variant_type)); } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: could not get parent object\n"))); + (TSTR("yaffs_mknod: could not get parent object\n"))); return -EPERM; } T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, " - "mode %x dev %x\n"), - dentry->d_name.name, mode, rdev)); + "mode %x dev %x\n"), + dentry->d_name.name, mode, rdev)); dev = parent->my_dev; @@ -1732,23 +1717,24 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, /* Special (socket, fifo, device...) */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n"))); #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) - obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, - gid, old_encode_dev(rdev)); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, old_encode_dev(rdev)); #else - obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, - gid, rdev); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, rdev); #endif break; case S_IFREG: /* file */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n"))); obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid, - gid); + gid); break; case S_IFDIR: /* directory */ - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: making directory\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n"))); obj = yaffs_create_dir(parent, dentry->d_name.name, mode, - uid, gid); + uid, gid); break; case S_IFLNK: /* symlink */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n"))); @@ -1764,13 +1750,12 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, d_instantiate(dentry, inode); update_dir_time(dir); T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod created object %d count = %d\n"), - obj->obj_id, atomic_read(&inode->i_count))); + (TSTR("yaffs_mknod created object %d count = %d\n"), + obj->obj_id, atomic_read(&inode->i_count))); error = 0; - yaffs_fill_inode_from_obj(dir,parent); + yaffs_fill_inode_from_obj(dir, parent); } else { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod failed making object\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n"))); error = -ENOMEM; } @@ -1792,7 +1777,7 @@ static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode) #endif { - T(YAFFS_TRACE_OS,(TSTR("yaffs_create\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n"))); return yaffs_mknod(dir, dentry, mode | S_IFREG, 0); } @@ -1800,13 +1785,12 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) { int ret_val; - yaffs_dev_t *dev; - yaffs_obj_t *obj; + struct yaffs_dev *dev; + struct yaffs_obj *obj; T(YAFFS_TRACE_OS, - (TSTR("yaffs_unlink %d:%s\n"), - (int)(dir->i_ino), - dentry->d_name.name)); + (TSTR("yaffs_unlink %d:%s\n"), + (int)(dir->i_ino), dentry->d_name.name)); obj = yaffs_inode_to_obj(dir); dev = obj->my_dev; @@ -1830,12 +1814,12 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) * Create a link... */ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry) + struct dentry *dentry) { struct inode *inode = old_dentry->d_inode; - yaffs_obj_t *obj = NULL; - yaffs_obj_t *link = NULL; - yaffs_dev_t *dev; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *link = NULL; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n"))); @@ -1844,23 +1828,24 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, yaffs_gross_lock(dev); - if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ - link = yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, - obj); + if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ + link = + yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, + obj); if (link) { old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj); d_instantiate(dentry, old_dentry->d_inode); atomic_inc(&old_dentry->d_inode->i_count); T(YAFFS_TRACE_OS, - (TSTR("yaffs_link link count %d i_count %d\n"), - old_dentry->d_inode->i_nlink, - atomic_read(&old_dentry->d_inode->i_count))); + (TSTR("yaffs_link link count %d i_count %d\n"), + old_dentry->d_inode->i_nlink, + atomic_read(&old_dentry->d_inode->i_count))); } yaffs_gross_unlock(dev); - if (link){ + if (link) { update_dir_time(dir); return 0; } @@ -1869,19 +1854,20 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, } static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname) + const char *symname) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); dev = yaffs_inode_to_obj(dir)->my_dev; yaffs_gross_lock(dev); obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name, - S_IFLNK | S_IRWXUGO, uid, gid, symname); + S_IFLNK | S_IRWXUGO, uid, gid, symname); yaffs_gross_unlock(dev); if (obj) { @@ -1903,12 +1889,12 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry, static int yaffs_sync_object(struct file *file, int datasync) #else static int yaffs_sync_object(struct file *file, struct dentry *dentry, - int datasync) + int datasync) #endif { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 34)) struct dentry *dentry = file->f_path.dentry; #endif @@ -1917,8 +1903,7 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry, dev = obj->my_dev; - T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_object\n"))); + T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n"))); yaffs_gross_lock(dev); yaffs_flush_file(obj, 1, datasync); yaffs_gross_unlock(dev); @@ -1933,9 +1918,9 @@ static int yaffs_sync_object(struct file *file, struct dentry *dentry, static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { - yaffs_dev_t *dev; + struct yaffs_dev *dev; int ret_val = YAFFS_FAIL; - yaffs_obj_t *target; + struct yaffs_obj *target; T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n"))); dev = yaffs_inode_to_obj(old_dir)->my_dev; @@ -1944,12 +1929,10 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, /* Check if the target is an existing directory that is not empty. */ target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); - - + new_dentry->d_name.name); if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&target->variant.dir_variant.children)) { + !list_empty(&target->variant.dir_variant.children)) { T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); @@ -1959,9 +1942,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n"))); ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir), - old_dentry->d_name.name, - yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); + old_dentry->d_name.name, + yaffs_inode_to_obj(new_dir), + new_dentry->d_name.name); } yaffs_gross_unlock(dev); @@ -1970,9 +1953,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, new_dentry->d_inode->i_nlink--; mark_inode_dirty(new_dentry->d_inode); } - + update_dir_time(old_dir); - if(old_dir != new_dir) + if (old_dir != new_dir) update_dir_time(new_dir); return 0; } else { @@ -1984,37 +1967,37 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr of object %d\n"), - yaffs_inode_to_obj(inode)->obj_id)); + (TSTR("yaffs_setattr of object %d\n"), + yaffs_inode_to_obj(inode)->obj_id)); - /* Fail if a requested resize >= 2GB */ - if (attr->ia_valid & ATTR_SIZE && - (attr->ia_size >> 31)) + /* Fail if a requested resize >= 2GB */ + if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31)) error = -EINVAL; if (error == 0) error = inode_change_ok(inode, attr); if (error == 0) { int result; - if (!error){ + if (!error) { error = yaffs_vfs_setattr(inode, attr); - T(YAFFS_TRACE_OS,(TSTR("inode_setattr called\n"))); - if (attr->ia_valid & ATTR_SIZE){ - yaffs_vfs_setsize(inode,attr->ia_size); - inode->i_blocks = (inode->i_size + 511) >> 9; + T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n"))); + if (attr->ia_valid & ATTR_SIZE) { + yaffs_vfs_setsize(inode, attr->ia_size); + inode->i_blocks = (inode->i_size + 511) >> 9; } } dev = yaffs_inode_to_obj(inode)->my_dev; - if (attr->ia_valid & ATTR_SIZE){ - T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), - (int)(attr->ia_size),(int)(attr->ia_size))); + if (attr->ia_valid & ATTR_SIZE) { + T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"), + (int)(attr->ia_size), + (int)(attr->ia_size))); } yaffs_gross_lock(dev); result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr); - if(result == YAFFS_OK) { + if (result == YAFFS_OK) { error = 0; } else { error = -EPERM; @@ -2023,56 +2006,49 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error)); return error; } #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags) + const void *value, size_t size, int flags) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); - - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr of object %d\n"), - obj->obj_id)); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_set_xattrib(obj, name, value, size, flags); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error)); return error; } - -ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size) +ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff, + size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr \"%s\" from object %d\n"), - name, obj->obj_id)); + (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -2081,8 +2057,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error)); return error; } @@ -2091,43 +2066,39 @@ int yaffs_removexattr(struct dentry *dentry, const char *name) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_remove_xattrib(obj, name); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr done returning %d\n"),error)); + (TSTR("yaffs_removexattr done returning %d\n"), error)); return error; } -ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) +ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -2136,28 +2107,26 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error)); return error; } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) { - yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; struct super_block *sb = dentry->d_sb; #elif (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); #else static int yaffs_statfs(struct super_block *sb, struct statfs *buf) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); #endif T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n"))); @@ -2174,14 +2143,17 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) uint64_t bytes_in_dev; uint64_t bytes_free; - bytes_in_dev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) * - ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk)); + bytes_in_dev = + ((uint64_t) + ((dev->param.end_block - dev->param.start_block + + 1))) * ((uint64_t) (dev->param.chunks_per_block * + dev->data_bytes_per_chunk)); - do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ + do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ buf->f_blocks = bytes_in_dev; - bytes_free = ((uint64_t)(yaffs_get_n_free_chunks(dev))) * - ((uint64_t)(dev->data_bytes_per_chunk)); + bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) * + ((uint64_t) (dev->data_bytes_per_chunk)); do_div(bytes_free, sb->s_blocksize); @@ -2190,21 +2162,21 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block / - (sb->s_blocksize / dev->data_bytes_per_chunk); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block / + (sb->s_blocksize / dev->data_bytes_per_chunk); buf->f_bfree = - yaffs_get_n_free_chunks(dev) / - (sb->s_blocksize / dev->data_bytes_per_chunk); + yaffs_get_n_free_chunks(dev) / + (sb->s_blocksize / dev->data_bytes_per_chunk); } else { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block * - (dev->data_bytes_per_chunk / sb->s_blocksize); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block * + (dev->data_bytes_per_chunk / sb->s_blocksize); buf->f_bfree = - yaffs_get_n_free_chunks(dev) * - (dev->data_bytes_per_chunk / sb->s_blocksize); + yaffs_get_n_free_chunks(dev) * + (dev->data_bytes_per_chunk / sb->s_blocksize); } buf->f_files = 0; @@ -2215,84 +2187,79 @@ static int yaffs_statfs(struct super_block *sb, struct statfs *buf) return 0; } - - static void yaffs_flush_inodes(struct super_block *sb) { struct inode *iptr; - yaffs_obj_t *obj; - - list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ + struct yaffs_obj *obj; + + list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) { obj = yaffs_inode_to_obj(iptr); - if(obj){ + if (obj) { T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), - obj->obj_id)); - yaffs_flush_file(obj,1,0); + obj->obj_id)); + yaffs_flush_file(obj, 1, 0); } } } - static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); - if(!dev) + struct yaffs_dev *dev = yaffs_super_to_dev(sb); + if (!dev) return; - + yaffs_flush_inodes(sb); yaffs_update_dirty_dirs(dev); yaffs_flush_whole_cache(dev); - if(do_checkpoint) + if (do_checkpoint) yaffs_checkpoint_save(dev); } - -static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev) +static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev) { - unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + unsigned erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - unsigned scattered = 0; /* Free chunks not in an erased block */ + unsigned scattered = 0; /* Free chunks not in an erased block */ - if(erased_chunks < dev->n_free_chunks) + if (erased_chunks < dev->n_free_chunks) scattered = (dev->n_free_chunks - erased_chunks); - if(!context->bg_running) + if (!context->bg_running) return 0; - else if(scattered < (dev->param.chunks_per_block * 2)) + else if (scattered < (dev->param.chunks_per_block * 2)) return 0; - else if(erased_chunks > dev->n_free_chunks/2) + else if (erased_chunks > dev->n_free_chunks / 2) return 0; - else if(erased_chunks > dev->n_free_chunks/4) + else if (erased_chunks > dev->n_free_chunks / 4) return 1; else return 2; } -static int yaffs_do_sync_fs(struct super_block *sb, - int request_checkpoint) +static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4); unsigned gc_urgent = yaffs_bg_gc_urgency(dev); int do_checkpoint; T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), - gc_urgent, - sb->s_dirt ? "dirty" : "clean", - request_checkpoint ? "checkpoint requested" : "no checkpoint", - oneshot_checkpoint ? " one-shot" : "" )); + (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), + gc_urgent, + sb->s_dirt ? "dirty" : "clean", + request_checkpoint ? "checkpoint requested" : "no checkpoint", + oneshot_checkpoint ? " one-shot" : "")); yaffs_gross_lock(dev); do_checkpoint = ((request_checkpoint && !gc_urgent) || - oneshot_checkpoint) && - !dev->is_checkpointed; + oneshot_checkpoint) && !dev->is_checkpointed; if (sb->s_dirt || do_checkpoint) { yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); sb->s_dirt = 0; - if(oneshot_checkpoint) + if (oneshot_checkpoint) yaffs_auto_checkpoint &= ~4; } yaffs_gross_unlock(dev); @@ -2321,7 +2288,7 @@ void yaffs_background_waker(unsigned long data) static int yaffs_bg_thread_fn(void *data) { - yaffs_dev_t *dev = (yaffs_dev_t *)data; + struct yaffs_dev *dev = (struct yaffs_dev *)data; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); unsigned long now = jiffies; unsigned long next_dir_update = now; @@ -2333,62 +2300,60 @@ static int yaffs_bg_thread_fn(void *data) struct timer_list timer; T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background starting for dev %p\n"), - (void *)dev)); + (TSTR("yaffs_background starting for dev %p\n"), (void *)dev)); #ifdef YAFFS_COMPILE_FREEZER set_freezable(); #endif - while(context->bg_running){ - T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background\n"))); + while (context->bg_running) { + T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n"))); - if(kthread_should_stop()) + if (kthread_should_stop()) break; #ifdef YAFFS_COMPILE_FREEZER - if(try_to_freeze()) + if (try_to_freeze()) continue; #endif yaffs_gross_lock(dev); now = jiffies; - if(time_after(now, next_dir_update) && yaffs_bg_enable){ + if (time_after(now, next_dir_update) && yaffs_bg_enable) { yaffs_update_dirty_dirs(dev); next_dir_update = now + HZ; } - if(time_after(now,next_gc) && yaffs_bg_enable){ - if(!dev->is_checkpointed){ + if (time_after(now, next_gc) && yaffs_bg_enable) { + if (!dev->is_checkpointed) { urgency = yaffs_bg_gc_urgency(dev); gc_result = yaffs_bg_gc(dev, urgency); - if(urgency > 1) - next_gc = now + HZ/20+1; - else if(urgency > 0) - next_gc = now + HZ/10+1; + if (urgency > 1) + next_gc = now + HZ / 20 + 1; + else if (urgency > 0) + next_gc = now + HZ / 10 + 1; else next_gc = now + HZ * 2; - } else /* - * gc not running so set to next_dir_update - * to cut down on wake ups - */ + } else /* + * gc not running so set to next_dir_update + * to cut down on wake ups + */ next_gc = next_dir_update; } yaffs_gross_unlock(dev); #if 1 expires = next_dir_update; - if (time_before(next_gc,expires)) + if (time_before(next_gc, expires)) expires = next_gc; - if(time_before(expires,now)) + if (time_before(expires, now)) expires = now + HZ; Y_INIT_TIMER(&timer); - timer.expires = expires+1; - timer.data = (unsigned long) current; + timer.expires = expires + 1; + timer.data = (unsigned long)current; timer.function = yaffs_background_waker; - set_current_state(TASK_INTERRUPTIBLE); + set_current_state(TASK_INTERRUPTIBLE); add_timer(&timer); schedule(); del_timer_sync(&timer); @@ -2400,20 +2365,21 @@ static int yaffs_bg_thread_fn(void *data) return 0; } -static int yaffs_bg_start(yaffs_dev_t *dev) +static int yaffs_bg_start(struct yaffs_dev *dev) { int retval = 0; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - if(dev->read_only) + if (dev->read_only) return -1; context->bg_running = 1; context->bg_thread = kthread_run(yaffs_bg_thread_fn, - (void *)dev,"yaffs-bg-%d",context->mount_id); + (void *)dev, "yaffs-bg-%d", + context->mount_id); - if(IS_ERR(context->bg_thread)){ + if (IS_ERR(context->bg_thread)) { retval = PTR_ERR(context->bg_thread); context->bg_thread = NULL; context->bg_running = 0; @@ -2421,13 +2387,13 @@ static int yaffs_bg_start(yaffs_dev_t *dev) return retval; } -static void yaffs_bg_stop(yaffs_dev_t *dev) +static void yaffs_bg_stop(struct yaffs_dev *dev) { struct yaffs_linux_context *ctxt = yaffs_dev_to_lc(dev); ctxt->bg_running = 0; - if( ctxt->bg_thread){ + if (ctxt->bg_thread) { kthread_stop(ctxt->bg_thread); ctxt->bg_thread = NULL; } @@ -2438,17 +2404,16 @@ static int yaffs_bg_thread_fn(void *data) return 0; } -static int yaffs_bg_start(yaffs_dev_t *dev) +static int yaffs_bg_start(struct yaffs_dev *dev) { return 0; } -static void yaffs_bg_stop(yaffs_dev_t *dev) +static void yaffs_bg_stop(struct yaffs_dev *dev) { } #endif - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static void yaffs_write_super(struct super_block *sb) #else @@ -2458,8 +2423,8 @@ static int yaffs_write_super(struct super_block *sb) unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_write_super%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_write_super%s\n"), + request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2468,7 +2433,6 @@ static int yaffs_write_super(struct super_block *sb) #endif } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs_sync_fs(struct super_block *sb, int wait) #else @@ -2478,8 +2442,7 @@ static int yaffs_sync_fs(struct super_block *sb) unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_fs%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2491,11 +2454,10 @@ static int yaffs_sync_fs(struct super_block *sb) static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) { struct inode *inode; - yaffs_obj_t *obj; - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_obj *obj; + struct yaffs_dev *dev = yaffs_super_to_dev(sb); - T(YAFFS_TRACE_OS, - (TSTR("yaffs_iget for %lu\n"), ino)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino)); inode = iget_locked(sb, ino); if (!inode) @@ -2529,55 +2491,54 @@ static void yaffs_read_inode(struct inode *inode) * need to lock again. */ - yaffs_obj_t *obj; - yaffs_dev_t *dev = yaffs_super_to_dev(inode->i_sb); + struct yaffs_obj *obj; + struct yaffs_dev *dev = yaffs_super_to_dev(inode->i_sb); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); + (TSTR("yaffs_read_inode for %d\n"), (int)inode->i_ino)); - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_lock(dev); obj = yaffs_find_by_number(dev, inode->i_ino); yaffs_fill_inode_from_obj(inode, obj); - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_unlock(dev); } #endif -static YLIST_HEAD(yaffs_context_list); -struct semaphore yaffs_context_lock; +static LIST_HEAD(yaffs_context_list); +struct mutex yaffs_context_lock; static void yaffs_put_super(struct super_block *sb) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("Shutting down yaffs background thread\n"))); + (TSTR("Shutting down yaffs background thread\n"))); yaffs_bg_stop(dev); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs background thread shut down\n"))); + (TSTR("yaffs background thread shut down\n"))); yaffs_gross_lock(dev); - yaffs_flush_super(sb,1); + yaffs_flush_super(sb, 1); if (yaffs_dev_to_lc(dev)->put_super_fn) yaffs_dev_to_lc(dev)->put_super_fn(sb); - yaffs_deinitialise(dev); yaffs_gross_unlock(dev); - down(&yaffs_context_lock); - ylist_del_init(&(yaffs_dev_to_lc(dev)->context_list)); - up(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); + list_del_init(&(yaffs_dev_to_lc(dev)->context_list)); + mutex_unlock(&yaffs_context_lock); if (yaffs_dev_to_lc(dev)->spare_buffer) { YFREE(yaffs_dev_to_lc(dev)->spare_buffer); @@ -2587,7 +2548,6 @@ static void yaffs_put_super(struct super_block *sb) kfree(dev); } - static void yaffs_mtd_put_super(struct super_block *sb) { struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb)); @@ -2598,8 +2558,7 @@ static void yaffs_mtd_put_super(struct super_block *sb) put_mtd_device(mtd); } - -static void yaffs_touch_super(yaffs_dev_t *dev) +static void yaffs_touch_super(struct yaffs_dev *dev) { struct super_block *sb = yaffs_dev_to_lc(dev)->super; @@ -2608,7 +2567,7 @@ static void yaffs_touch_super(yaffs_dev_t *dev) sb->s_dirt = 1; } -typedef struct { +struct yaffs_options { int inband_tags; int skip_checkpoint_read; int skip_checkpoint_write; @@ -2619,10 +2578,11 @@ typedef struct { int lazy_loading_overridden; int empty_lost_and_found; int empty_lost_and_found_overridden; -} yaffs_options; +}; #define MAX_OPT_LEN 30 -static int yaffs_parse_options(yaffs_options *options, const char *options_str) +static int yaffs_parse_options(struct yaffs_options *options, + const char *options_str) { char cur_opt[MAX_OPT_LEN + 1]; int p; @@ -2634,7 +2594,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) memset(cur_opt, 0, MAX_OPT_LEN + 1); p = 0; - while(*options_str == ',') + while (*options_str == ',') options_str++; while (*options_str && *options_str != ',') { @@ -2647,24 +2607,24 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) if (!strcmp(cur_opt, "inband-tags")) options->inband_tags = 1; - else if (!strcmp(cur_opt, "tags-ecc-off")){ + else if (!strcmp(cur_opt, "tags-ecc-off")) { options->tags_ecc_on = 0; - options->tags_ecc_overridden=1; - } else if (!strcmp(cur_opt, "tags-ecc-on")){ + options->tags_ecc_overridden = 1; + } else if (!strcmp(cur_opt, "tags-ecc-on")) { options->tags_ecc_on = 1; options->tags_ecc_overridden = 1; - } else if (!strcmp(cur_opt, "lazy-loading-off")){ + } else if (!strcmp(cur_opt, "lazy-loading-off")) { options->lazy_loading_enabled = 0; - options->lazy_loading_overridden=1; - } else if (!strcmp(cur_opt, "lazy-loading-on")){ + options->lazy_loading_overridden = 1; + } else if (!strcmp(cur_opt, "lazy-loading-on")) { options->lazy_loading_enabled = 1; options->lazy_loading_overridden = 1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-off")){ + } else if (!strcmp(cur_opt, "empty-lost-and-found-off")) { options->empty_lost_and_found = 0; - options->empty_lost_and_found_overridden=1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-on")){ + options->empty_lost_and_found_overridden = 1; + } else if (!strcmp(cur_opt, "empty-lost-and-found-on")) { options->empty_lost_and_found = 1; - options->empty_lost_and_found_overridden=1; + options->empty_lost_and_found_overridden = 1; } else if (!strcmp(cur_opt, "no-cache")) options->no_cache = 1; else if (!strcmp(cur_opt, "no-checkpoint-read")) @@ -2676,7 +2636,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) options->skip_checkpoint_write = 1; } else { printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n", - cur_opt); + cur_opt); error = 1; } } @@ -2685,35 +2645,34 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) } static struct super_block *yaffs_internal_read_super(int yaffs_version, - struct super_block *sb, - void *data, int silent) + struct super_block *sb, + void *data, int silent) { int n_blocks; struct inode *inode = NULL; struct dentry *root; - yaffs_dev_t *dev = 0; + struct yaffs_dev *dev = 0; char devname_buf[BDEVNAME_SIZE + 1]; struct mtd_info *mtd; int err; char *data_str = (char *)data; struct yaffs_linux_context *context = NULL; - yaffs_param_t *param; + struct yaffs_param *param; int read_only = 0; - yaffs_options options; + struct yaffs_options options; unsigned mount_id; int found; struct yaffs_linux_context *context_iterator; - struct ylist_head *l; + struct list_head *l; sb->s_magic = YAFFS_MAGIC; sb->s_op = &yaffs_super_ops; sb->s_flags |= MS_NOATIME; - read_only =((sb->s_flags & MS_RDONLY) != 0); - + read_only = ((sb->s_flags & MS_RDONLY) != 0); #ifdef YAFFS_COMPILE_EXPORTFS sb->s_export_op = &yaffs_export_ops; @@ -2728,8 +2687,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, else printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", sb->s_dev, - yaffs_devname(sb, devname_buf), - read_only ? "ro" : "rw"); + yaffs_devname(sb, devname_buf), read_only ? "ro" : "rw"); if (!data_str) data_str = ""; @@ -2743,20 +2701,17 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, return NULL; } - sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); + (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: block size %d\n"), - (int)(sb->s_blocksize))); + (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize))); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), - MAJOR(sb->s_dev), MINOR(sb->s_dev), - yaffs_devname(sb, devname_buf))); + (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), + MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf))); /* Check it's an mtd device..... */ if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) @@ -2766,15 +2721,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); if (!mtd) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), - MINOR(sb->s_dev))); + (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), + MINOR(sb->s_dev))); return NULL; } /* Check it's NAND */ if (mtd->type != MTD_NANDFLASH) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device is not NAND it's type %d\n"), - mtd->type)); + (TSTR("yaffs: MTD device is not NAND it's type %d\n"), + mtd->type)); return NULL; } @@ -2797,27 +2752,23 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_AUTO_YAFFS2 if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs2\n"))); + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n"))); yaffs_version = 2; } /* Added NCB 26/5/2006 for completeness */ - if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs1\n"))); + if (yaffs_version == 2 && !options.inband_tags + && WRITE_SIZE(mtd) == 512) { + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n"))); yaffs_version = 1; } - #endif if (yaffs_version == 2) { /* Check for version 2 style functions */ if (!mtd->erase || !mtd->block_isbad || - !mtd->block_markbad || - !mtd->read || - !mtd->write || + !mtd->block_markbad || !mtd->read || !mtd->write || #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) !mtd->read_oob || !mtd->write_oob) { #else @@ -2826,23 +2777,21 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #endif T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE || - mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && + mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && !options.inband_tags) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } else { /* Check for V1 style functions */ - if (!mtd->erase || - !mtd->read || - !mtd->write || + if (!mtd->erase || !mtd->read || !mtd->write || #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) !mtd->read_oob || !mtd->write_oob) { #else @@ -2851,7 +2800,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #endif T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } @@ -2859,29 +2808,30 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd->oobsize != YAFFS_BYTES_PER_SPARE) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } /* OK, so if we got here, we have an MTD that's NAND and looks * like it has the right capabilities - * Set the yaffs_dev_t up for mtd + * Set the struct yaffs_dev up for mtd */ - if (!read_only && !(mtd->flags & MTD_WRITEABLE)){ + if (!read_only && !(mtd->flags & MTD_WRITEABLE)) { read_only = 1; - printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); + printk(KERN_INFO + "yaffs: mtd is read only, setting superblock read only"); sb->s_flags |= MS_RDONLY; } - dev = kmalloc(sizeof(yaffs_dev_t), GFP_KERNEL); - context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL); - - if(!dev || !context ){ - if(dev) + dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL); + context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL); + + if (!dev || !context) { + if (dev) kfree(dev); - if(context) + if (context) kfree(context); dev = NULL; context = NULL; @@ -2891,15 +2841,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Deep shit could not allocate device structure */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs_read_super: Failed trying to allocate " - "yaffs_dev_t. \n"))); + "struct yaffs_dev. \n"))); return NULL; } - memset(dev, 0, sizeof(yaffs_dev_t)); + memset(dev, 0, sizeof(struct yaffs_dev)); param = &(dev->param); - memset(context,0,sizeof(struct yaffs_linux_context)); + memset(context, 0, sizeof(struct yaffs_linux_context)); dev->os_context = context; - YINIT_LIST_HEAD(&(context->context_list)); + INIT_LIST_HEAD(&(context->context_list)); context->dev = dev; context->super = sb; @@ -2910,13 +2860,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #else sb->u.generic_sbp = dev; #endif - + dev->driver_context = mtd; param->name = mtd->name; /* Set up the memory size parameters.... */ - n_blocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); + n_blocks = + YCALCBLOCKS(mtd->size, + (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); param->start_block = 0; param->end_block = n_blocks - 1; @@ -2932,7 +2884,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_XATTR param->enable_xattr = 1; #endif - if(options.lazy_loading_overridden) + if (options.lazy_loading_overridden) param->disable_lazy_load = !options.lazy_loading_enabled; #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC @@ -2944,7 +2896,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->defered_dir_update = 1; #endif - if(options.tags_ecc_overridden) + if (options.tags_ecc_overridden) param->no_tags_ecc = !options.tags_ecc_on; #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND @@ -2961,15 +2913,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->always_check_erased = 1; #endif - if(options.empty_lost_and_found_overridden) + if (options.empty_lost_and_found_overridden) param->empty_lost_n_found = options.empty_lost_and_found; /* ... and the functions. */ if (yaffs_version == 2) { - param->write_chunk_tags_fn = - nandmtd2_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd2_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd2_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd2_read_chunk_tags; param->bad_block_fn = nandmtd2_mark_block_bad; param->query_block_fn = nandmtd2_query_block; yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize); @@ -2988,10 +2938,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, } else { #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) /* use the MTD interface in yaffs_mtdif1.c */ - param->write_chunk_tags_fn = - nandmtd1_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd1_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd1_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd1_read_chunk_tags; param->bad_block_fn = nandmtd1_mark_block_bad; param->query_block_fn = nandmtd1_query_block; #else @@ -3009,8 +2957,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->sb_dirty_fn = yaffs_touch_super; param->gc_control = yaffs_gc_control_callback; - yaffs_dev_to_lc(dev)->super= sb; - + yaffs_dev_to_lc(dev)->super = sb; #ifndef CONFIG_YAFFS_DOES_ECC param->use_nand_ecc = 1; @@ -3023,27 +2970,30 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->skip_checkpt_rd = options.skip_checkpoint_read; param->skip_checkpt_wr = options.skip_checkpoint_write; - down(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); /* Get a mount id */ found = 0; - for(mount_id=0; ! found; mount_id++){ + for (mount_id = 0; !found; mount_id++) { found = 1; - ylist_for_each(l,&yaffs_context_list){ - context_iterator = ylist_entry(l,struct yaffs_linux_context,context_list); - if(context_iterator->mount_id == mount_id) + list_for_each(l, &yaffs_context_list) { + context_iterator = + list_entry(l, struct yaffs_linux_context, + context_list); + if (context_iterator->mount_id == mount_id) found = 0; } } context->mount_id = mount_id; - ylist_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list); - up(&yaffs_context_lock); + list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), + &yaffs_context_list); + mutex_unlock(&yaffs_context_lock); - /* Directory search handling...*/ - YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); - param->remove_obj_fn = yaffs_remove_obj_callback; + /* Directory search handling... */ + INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); + param->remove_obj_fn = yaffs_remove_obj_callback; - init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock)); + mutex_init(&(yaffs_dev_to_lc(dev)->gross_lock)); yaffs_gross_lock(dev); @@ -3052,21 +3002,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: guts initialised %s\n"), (err == YAFFS_OK) ? "OK" : "FAILED")); - - if(err == YAFFS_OK) + + if (err == YAFFS_OK) yaffs_bg_start(dev); - - if(!context->bg_thread) - param->defered_dir_update = 0; + if (!context->bg_thread) + param->defered_dir_update = 0; /* Release lock before yaffs_get_inode() */ yaffs_gross_unlock(dev); /* Create root inode */ if (err == YAFFS_OK) - inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, - yaffs_root(dev)); + inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_root(dev)); if (!inode) return NULL; @@ -3087,14 +3035,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_root = root; sb->s_dirt = !dev->is_checkpointed; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_read_super: is_checkpointed %d\n"), - dev->is_checkpointed)); + (TSTR("yaffs_read_super: is_checkpointed %d\n"), + dev->is_checkpointed)); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); return sb; } - #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data, int silent) @@ -3140,7 +3087,6 @@ static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super, FS_REQUIRES_DEV); #endif - #ifdef CONFIG_YAFFS_YAFFS2 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)) @@ -3152,11 +3098,11 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 17)) static int yaffs2_read_super(struct file_system_type *fs, - int flags, const char *dev_name, void *data, - struct vfsmount *mnt) + int flags, const char *dev_name, void *data, + struct vfsmount *mnt) { return get_sb_bdev(fs, flags, dev_name, data, - yaffs2_internal_read_super_mtd, mnt); + yaffs2_internal_read_super_mtd, mnt); } #else static struct super_block *yaffs2_read_super(struct file_system_type *fs, @@ -3187,40 +3133,58 @@ static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super, FS_REQUIRES_DEV); #endif -#endif /* CONFIG_YAFFS_YAFFS2 */ +#endif /* CONFIG_YAFFS_YAFFS2 */ static struct proc_dir_entry *my_proc_entry; static struct proc_dir_entry *debug_proc_entry; -static char *yaffs_dump_dev_part0(char *buf, yaffs_dev_t * dev) +static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "start_block.......... %d\n", dev->param.start_block); + buf += + sprintf(buf, "start_block.......... %d\n", dev->param.start_block); buf += sprintf(buf, "end_block............ %d\n", dev->param.end_block); - buf += sprintf(buf, "total_bytes_per_chunk %d\n", dev->param.total_bytes_per_chunk); - buf += sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); - buf += sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); + buf += + sprintf(buf, "total_bytes_per_chunk %d\n", + dev->param.total_bytes_per_chunk); + buf += + sprintf(buf, "use_nand_ecc......... %d\n", dev->param.use_nand_ecc); + buf += + sprintf(buf, "no_tags_ecc.......... %d\n", dev->param.no_tags_ecc); buf += sprintf(buf, "is_yaffs2............ %d\n", dev->param.is_yaffs2); - buf += sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags); - buf += sprintf(buf, "empty_lost_n_found... %d\n", dev->param.empty_lost_n_found); - buf += sprintf(buf, "disable_lazy_load.... %d\n", dev->param.disable_lazy_load); - buf += sprintf(buf, "refresh_period....... %d\n", dev->param.refresh_period); + buf += + sprintf(buf, "inband_tags.......... %d\n", dev->param.inband_tags); + buf += + sprintf(buf, "empty_lost_n_found... %d\n", + dev->param.empty_lost_n_found); + buf += + sprintf(buf, "disable_lazy_load.... %d\n", + dev->param.disable_lazy_load); + buf += + sprintf(buf, "refresh_period....... %d\n", + dev->param.refresh_period); buf += sprintf(buf, "n_caches............. %d\n", dev->param.n_caches); - buf += sprintf(buf, "n_reserved_blocks.... %d\n", dev->param.n_reserved_blocks); - buf += sprintf(buf, "always_check_erased.. %d\n", dev->param.always_check_erased); + buf += + sprintf(buf, "n_reserved_blocks.... %d\n", + dev->param.n_reserved_blocks); + buf += + sprintf(buf, "always_check_erased.. %d\n", + dev->param.always_check_erased); buf += sprintf(buf, "\n"); return buf; } - -static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev) +static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "data_bytes_per_chunk. %d\n", dev->data_bytes_per_chunk); + buf += + sprintf(buf, "data_bytes_per_chunk. %d\n", + dev->data_bytes_per_chunk); buf += sprintf(buf, "chunk_grp_bits....... %d\n", dev->chunk_grp_bits); buf += sprintf(buf, "chunk_grp_size....... %d\n", dev->chunk_grp_size); buf += sprintf(buf, "n_erased_blocks...... %d\n", dev->n_erased_blocks); - buf += sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt); + buf += + sprintf(buf, "blocks_in_checkpt.... %d\n", dev->blocks_in_checkpt); buf += sprintf(buf, "\n"); buf += sprintf(buf, "n_tnodes............. %d\n", dev->n_tnodes); buf += sprintf(buf, "n_obj................ %d\n", dev->n_obj); @@ -3231,19 +3195,27 @@ static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev) buf += sprintf(buf, "n_erasures........... %u\n", dev->n_erasures); buf += sprintf(buf, "n_gc_copies.......... %u\n", dev->n_gc_copies); buf += sprintf(buf, "all_gcs.............. %u\n", dev->all_gcs); - buf += sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count); - buf += sprintf(buf, "oldest_dirty_gc_count %u\n", dev->oldest_dirty_gc_count); + buf += + sprintf(buf, "passive_gc_count..... %u\n", dev->passive_gc_count); + buf += + sprintf(buf, "oldest_dirty_gc_count %u\n", + dev->oldest_dirty_gc_count); buf += sprintf(buf, "n_gc_blocks.......... %u\n", dev->n_gc_blocks); buf += sprintf(buf, "bg_gcs............... %u\n", dev->bg_gcs); - buf += sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); - buf += sprintf(buf, "n_retired_blocks..... %u\n", dev->n_retired_blocks); + buf += + sprintf(buf, "n_retired_writes..... %u\n", dev->n_retired_writes); + buf += + sprintf(buf, "n_retired_blocks..... %u\n", dev->n_retired_blocks); buf += sprintf(buf, "n_ecc_fixed.......... %u\n", dev->n_ecc_fixed); buf += sprintf(buf, "n_ecc_unfixed........ %u\n", dev->n_ecc_unfixed); - buf += sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed); - buf += sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed); + buf += + sprintf(buf, "n_tags_ecc_fixed..... %u\n", dev->n_tags_ecc_fixed); + buf += + sprintf(buf, "n_tags_ecc_unfixed... %u\n", dev->n_tags_ecc_unfixed); buf += sprintf(buf, "cache_hits........... %u\n", dev->cache_hits); buf += sprintf(buf, "n_deleted_files...... %u\n", dev->n_deleted_files); - buf += sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); + buf += + sprintf(buf, "n_unlinked_files..... %u\n", dev->n_unlinked_files); buf += sprintf(buf, "refresh_count........ %u\n", dev->refresh_count); buf += sprintf(buf, "n_bg_deletions....... %u\n", dev->n_bg_deletions); @@ -3254,7 +3226,7 @@ static int yaffs_proc_read(char *page, char **start, off_t offset, int count, int *eof, void *data) { - struct ylist_head *item; + struct list_head *item; char *buf = page; int step = offset; int n = 0; @@ -3269,63 +3241,71 @@ static int yaffs_proc_read(char *page, /* Print header first */ if (step == 0) - buf += sprintf(buf, "Multi-version YAFFS built:" __DATE__ " " __TIME__"\n"); + buf += + sprintf(buf, + "Multi-version YAFFS built:" __DATE__ " " __TIME__ + "\n"); else if (step == 1) - buf += sprintf(buf,"\n"); + buf += sprintf(buf, "\n"); else { - step-=2; - - down(&yaffs_context_lock); + step -= 2; + + mutex_lock(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ - ylist_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list); - yaffs_dev_t *dev = dc->dev; + list_for_each(item, &yaffs_context_list) { + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, + context_list); + struct yaffs_dev *dev = dc->dev; if (n < (step & ~1)) { - n+=2; + n += 2; continue; } - if((step & 1)==0){ - buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->param.name); + if ((step & 1) == 0) { + buf += + sprintf(buf, "\nDevice %d \"%s\"\n", n, + dev->param.name); buf = yaffs_dump_dev_part0(buf, dev); } else buf = yaffs_dump_dev_part1(buf, dev); - + break; } - up(&yaffs_context_lock); + mutex_unlock(&yaffs_context_lock); } return buf - page < count ? buf - page : count; } static int yaffs_stats_proc_read(char *page, - char **start, - off_t offset, int count, int *eof, void *data) + char **start, + off_t offset, int count, int *eof, void *data) { - struct ylist_head *item; + struct list_head *item; char *buf = page; int n = 0; - down(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ - ylist_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list); - yaffs_dev_t *dev = dc->dev; + list_for_each(item, &yaffs_context_list) { + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, context_list); + struct yaffs_dev *dev = dc->dev; int erased_chunks; - erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - - buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", - n, dev->n_free_chunks, erased_chunks, - dev->bg_gcs, dev->oldest_dirty_gc_count, - dev->n_obj, dev->n_tnodes); - } - up(&yaffs_context_lock); + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; + buf += sprintf(buf, "%d, %d, %d, %u, %u, %u, %u\n", + n, dev->n_free_chunks, erased_chunks, + dev->bg_gcs, dev->oldest_dirty_gc_count, + dev->n_obj, dev->n_tnodes); + } + mutex_unlock(&yaffs_context_lock); return buf - page < count ? buf - page : count; } @@ -3340,41 +3320,39 @@ static struct { char *mask_name; unsigned mask_bitfield; } mask_flags[] = { - {"allocate", YAFFS_TRACE_ALLOCATE}, - {"always", YAFFS_TRACE_ALWAYS}, - {"background", YAFFS_TRACE_BACKGROUND}, - {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, - {"buffers", YAFFS_TRACE_BUFFERS}, - {"bug", YAFFS_TRACE_BUG}, - {"checkpt", YAFFS_TRACE_CHECKPOINT}, - {"deletion", YAFFS_TRACE_DELETION}, - {"erase", YAFFS_TRACE_ERASE}, - {"error", YAFFS_TRACE_ERROR}, - {"gc_detail", YAFFS_TRACE_GC_DETAIL}, - {"gc", YAFFS_TRACE_GC}, - {"lock", YAFFS_TRACE_LOCK}, - {"mtd", YAFFS_TRACE_MTD}, - {"nandaccess", YAFFS_TRACE_NANDACCESS}, - {"os", YAFFS_TRACE_OS}, - {"scan_debug", YAFFS_TRACE_SCAN_DEBUG}, - {"scan", YAFFS_TRACE_SCAN}, - {"tracing", YAFFS_TRACE_TRACING}, - {"sync", YAFFS_TRACE_SYNC}, - {"write", YAFFS_TRACE_WRITE}, - - {"verify", YAFFS_TRACE_VERIFY}, - {"verify_nand", YAFFS_TRACE_VERIFY_NAND}, - {"verify_full", YAFFS_TRACE_VERIFY_FULL}, - {"verify_all", YAFFS_TRACE_VERIFY_ALL}, - - {"all", 0xffffffff}, - {"none", 0}, - {NULL, 0}, -}; + { + "allocate", YAFFS_TRACE_ALLOCATE}, { + "always", YAFFS_TRACE_ALWAYS}, { + "background", YAFFS_TRACE_BACKGROUND}, { + "bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, { + "buffers", YAFFS_TRACE_BUFFERS}, { + "bug", YAFFS_TRACE_BUG}, { + "checkpt", YAFFS_TRACE_CHECKPOINT}, { + "deletion", YAFFS_TRACE_DELETION}, { + "erase", YAFFS_TRACE_ERASE}, { + "error", YAFFS_TRACE_ERROR}, { + "gc_detail", YAFFS_TRACE_GC_DETAIL}, { + "gc", YAFFS_TRACE_GC}, { + "lock", YAFFS_TRACE_LOCK}, { + "mtd", YAFFS_TRACE_MTD}, { + "nandaccess", YAFFS_TRACE_NANDACCESS}, { + "os", YAFFS_TRACE_OS}, { + "scan_debug", YAFFS_TRACE_SCAN_DEBUG}, { + "scan", YAFFS_TRACE_SCAN}, { + "tracing", YAFFS_TRACE_TRACING}, { + "sync", YAFFS_TRACE_SYNC}, { + "write", YAFFS_TRACE_WRITE}, { + "verify", YAFFS_TRACE_VERIFY}, { + "verify_nand", YAFFS_TRACE_VERIFY_NAND}, { + "verify_full", YAFFS_TRACE_VERIFY_FULL}, { + "verify_all", YAFFS_TRACE_VERIFY_ALL}, { + "all", 0xffffffff}, { + "none", 0}, { +NULL, 0},}; #define MAX_MASK_NAME_LENGTH 40 static int yaffs_proc_write_trace_options(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { unsigned rg = 0, mask_bitfield; char *end; @@ -3416,15 +3394,17 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, done = 0; } else { for (x = buf + pos, i = 0; - (*x == '_' || (*x >= 'a' && *x <= 'z')) && - i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) + (*x == '_' || (*x >= 'a' && *x <= 'z')) && + i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) substring[i] = *x; substring[i] = '\0'; for (i = 0; mask_flags[i].mask_name != NULL; i++) { - if (strcmp(substring, mask_flags[i].mask_name) == 0) { + if (strcmp(substring, mask_flags[i].mask_name) + == 0) { mask_name = mask_flags[i].mask_name; - mask_bitfield = mask_flags[i].mask_bitfield; + mask_bitfield = + mask_flags[i].mask_bitfield; done = 0; break; } @@ -3459,18 +3439,18 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, char flag; flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-'; - printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name); + printk(KERN_DEBUG "%c%s\n", flag, + mask_flags[i].mask_name); } } return count; } - static int yaffs_proc_write(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { - return yaffs_proc_write_trace_options(file, buf, count, data); + return yaffs_proc_write_trace_options(file, buf, count, data); } /* Stuff to handle installation of file systems */ @@ -3495,18 +3475,15 @@ static int __init init_yaffs_fs(void) #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED T(YAFFS_TRACE_ALWAYS, - (TSTR(" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); + (TSTR + (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); #endif - - - - init_MUTEX(&yaffs_context_lock); + mutex_init(&yaffs_context_lock); /* Install the proc_fs entries */ my_proc_entry = create_proc_entry("yaffs", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (my_proc_entry) { my_proc_entry->write_proc = yaffs_proc_write; @@ -3516,8 +3493,7 @@ static int __init init_yaffs_fs(void) return -ENOMEM; debug_proc_entry = create_proc_entry("yaffs_stats", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (debug_proc_entry) { debug_proc_entry->write_proc = NULL; @@ -3559,7 +3535,7 @@ static void __exit exit_yaffs_fs(void) struct file_system_to_install *fsinst; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); + (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); remove_proc_entry("yaffs", YPROC_ROOT); remove_proc_entry("yaffs_stats", YPROC_ROOT); @@ -3576,8 +3552,8 @@ static void __exit exit_yaffs_fs(void) } module_init(init_yaffs_fs) -module_exit(exit_yaffs_fs) + module_exit(exit_yaffs_fs) -MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); + MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010"); MODULE_LICENSE("GPL"); diff --git a/yaffs_vfs.c b/yaffs_vfs_single.c similarity index 66% rename from yaffs_vfs.c rename to yaffs_vfs_single.c index b1b6840..a17262c 100644 --- a/yaffs_vfs.c +++ b/yaffs_vfs_single.c @@ -24,11 +24,11 @@ * the VFS. * * Special notes: - * >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with + * >> 2.4: sb->u.generic_sbp points to the struct yaffs_dev associated with * this superblock - * >> 2.6: sb->s_fs_info points to the yaffs_dev_t associated with this + * >> 2.6: sb->s_fs_info points to the struct yaffs_dev associated with this * superblock - * >> inode->u.generic_ip points to the associated yaffs_obj_t. + * >> inode->u.generic_ip points to the associated struct yaffs_obj. */ /* @@ -57,7 +57,6 @@ #include - #include #define UnlockPage(p) unlock_page(p) @@ -72,12 +71,11 @@ #define WRITE_SIZE_STR "writesize" #define WRITE_SIZE(mtd) ((mtd)->writesize) - static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) { uint64_t result = partition_size; do_div(result, block_size); - return (uint32_t)result; + return (uint32_t) result; } #include @@ -86,6 +84,7 @@ static uint32_t YCALCBLOCKS(uint64_t partition_size, uint32_t block_size) #include "yportenv.h" #include "yaffs_trace.h" #include "yaffs_guts.h" +#include "yaffs_attribs.h" #include "yaffs_linux.h" @@ -111,19 +110,18 @@ module_param(yaffs_bg_enable, uint, 0644); static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino); #define yaffs_inode_to_obj_lv(iptr) ((iptr)->i_private) -#define yaffs_inode_to_obj(iptr) ((yaffs_obj_t *)(yaffs_inode_to_obj_lv(iptr))) +#define yaffs_inode_to_obj(iptr) ((struct yaffs_obj *)(yaffs_inode_to_obj_lv(iptr))) #define yaffs_dentry_to_obj(dptr) yaffs_inode_to_obj((dptr)->d_inode) -#define yaffs_super_to_dev(sb) ((yaffs_dev_t *)sb->s_fs_info) - +#define yaffs_super_to_dev(sb) ((struct yaffs_dev *)sb->s_fs_info) #define update_dir_time(dir) do {\ (dir)->i_ctime = (dir)->i_mtime = CURRENT_TIME; \ } while(0) - + static void yaffs_put_super(struct super_block *sb); static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos); + loff_t * pos); static ssize_t yaffs_hold_space(struct file *f); static void yaffs_release_space(struct file *f); @@ -136,16 +134,16 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir); static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n); static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n); + struct nameidata *n); static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry); + struct dentry *dentry); static int yaffs_unlink(struct inode *dir, struct dentry *dentry); static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname); + const char *symname); static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode); static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t dev); + dev_t dev); static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry); static int yaffs_setattr(struct dentry *dentry, struct iattr *attr); @@ -166,33 +164,31 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc); #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags); + const void *value, size_t size, int flags); ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size); + size_t size); int yaffs_removexattr(struct dentry *dentry, const char *name); ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size); #endif - static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata); + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata); static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata); + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata); -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen); +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen); void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias); static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd); -static void yaffs_touch_super(yaffs_dev_t *dev); +static void yaffs_touch_super(struct yaffs_dev *dev); static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin); static int yaffs_vfs_setattr(struct inode *, struct iattr *); - static struct address_space_operations yaffs_file_address_operations = { .readpage = yaffs_readpage, .writepage = yaffs_writepage, @@ -200,7 +196,6 @@ static struct address_space_operations yaffs_file_address_operations = { .write_end = yaffs_write_end, }; - static const struct file_operations yaffs_file_operations = { .read = do_sync_read, .write = do_sync_write, @@ -214,8 +209,6 @@ static const struct file_operations yaffs_file_operations = { .llseek = generic_file_llseek, }; - - static const struct inode_operations yaffs_file_inode_operations = { .setattr = yaffs_setattr, #ifdef CONFIG_YAFFS_XATTR @@ -276,56 +269,57 @@ static const struct super_operations yaffs_super_ops = { .write_super = yaffs_write_super, }; - -static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) +static int yaffs_vfs_setattr(struct inode *inode, struct iattr *attr) { - setattr_copy(inode,attr); + setattr_copy(inode, attr); return 0; } -static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) +static int yaffs_vfs_setsize(struct inode *inode, loff_t newsize) { - truncate_setsize(inode,newsize); + truncate_setsize(inode, newsize); return 0; } -static unsigned yaffs_gc_control_callback(yaffs_dev_t *dev) +static unsigned yaffs_gc_control_callback(struct yaffs_dev *dev) { return yaffs_gc_control; } - -static void yaffs_gross_lock(yaffs_dev_t *dev) + +static void yaffs_gross_lock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs locking %p\n"), current)); - down(&(yaffs_dev_to_lc(dev)->gross_lock)); + mutex_lock(&(yaffs_dev_to_lc(dev)->gross_lock)); T(YAFFS_TRACE_LOCK, (TSTR("yaffs locked %p\n"), current)); } -static void yaffs_gross_unlock(yaffs_dev_t *dev) +static void yaffs_gross_unlock(struct yaffs_dev *dev) { T(YAFFS_TRACE_LOCK, (TSTR("yaffs unlocking %p\n"), current)); - up(&(yaffs_dev_to_lc(dev)->gross_lock)); + mutex_unlock(&(yaffs_dev_to_lc(dev)->gross_lock)); } - - /* ExportFS support */ -static struct inode * -yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, uint32_t generation) +static struct inode *yaffs2_nfs_get_inode(struct super_block *sb, uint64_t ino, + uint32_t generation) { return Y_IGET(sb, ino); } -static struct dentry * -yaffs2_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_dentry(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_dentry(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode) ; + return generic_fh_to_dentry(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } -static struct dentry * - yaffs2_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type) +static struct dentry *yaffs2_fh_to_parent(struct super_block *sb, + struct fid *fid, int fh_len, + int fh_type) { - return generic_fh_to_parent(sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode); + return generic_fh_to_parent(sb, fid, fh_len, fh_type, + yaffs2_nfs_get_inode); } struct dentry *yaffs2_get_parent(struct dentry *dentry) @@ -335,8 +329,8 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) struct dentry *parent = ERR_PTR(-ENOENT); struct inode *inode; unsigned long parent_ino; - yaffs_obj_t *d_obj; - yaffs_obj_t *parent_obj; + struct yaffs_obj *d_obj; + struct yaffs_obj *parent_obj; d_obj = yaffs_inode_to_obj(dentry->d_inode); @@ -365,12 +359,11 @@ struct dentry *yaffs2_get_parent(struct dentry *dentry) * using the default functions of exportfs. */ -static struct export_operations yaffs_export_ops = -{ +static struct export_operations yaffs_export_ops = { .fh_to_dentry = yaffs2_fh_to_dentry, .fh_to_parent = yaffs2_fh_to_parent, .get_parent = yaffs2_get_parent, -} ; +}; /*-----------------------------------------------------------------*/ /* Directory search context allows us to unlock access to yaffs during @@ -384,7 +377,7 @@ static struct export_operations yaffs_export_ops = * next object before the object is deleted. * * Many readdirs (and thus seach conexts) may be alive simulateously so - * each yaffs_dev_t has a list of these. + * each struct yaffs_dev has a list of these. * * A seach context lives for the duration of a readdir. * @@ -392,10 +385,10 @@ static struct export_operations yaffs_export_ops = */ struct yaffs_search_context { - yaffs_dev_t *dev; - yaffs_obj_t *dir_obj; - yaffs_obj_t *next_return; - struct ylist_head others; + struct yaffs_dev *dev; + struct yaffs_obj *dir_obj; + struct yaffs_obj *next_return; + struct list_head others; }; /* @@ -404,21 +397,22 @@ struct yaffs_search_context { * * Called at start of readdir. */ -static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir) +static struct yaffs_search_context *yaffs_new_search(struct yaffs_obj *dir) { - yaffs_dev_t *dev = dir->my_dev; - struct yaffs_search_context *sc = YMALLOC(sizeof(struct yaffs_search_context)); - if(sc){ + struct yaffs_dev *dev = dir->my_dev; + struct yaffs_search_context *sc = + YMALLOC(sizeof(struct yaffs_search_context)); + if (sc) { sc->dir_obj = dir; sc->dev = dev; - if( ylist_empty(&sc->dir_obj->variant.dir_variant.children)) + if (list_empty(&sc->dir_obj->variant.dir_variant.children)) sc->next_return = NULL; else - sc->next_return = ylist_entry( - dir->variant.dir_variant.children.next, - yaffs_obj_t,siblings); - YINIT_LIST_HEAD(&sc->others); - ylist_add(&sc->others,&(yaffs_dev_to_lc(dev)->search_contexts)); + sc->next_return = + list_entry(dir->variant.dir_variant.children.next, + struct yaffs_obj, siblings); + INIT_LIST_HEAD(&sc->others); + list_add(&sc->others, &(yaffs_dev_to_lc(dev)->search_contexts)); } return sc; } @@ -426,10 +420,10 @@ static struct yaffs_search_context * yaffs_new_search(yaffs_obj_t *dir) /* * yaffs_search_end() disposes of a search context and cleans up. */ -static void yaffs_search_end(struct yaffs_search_context * sc) +static void yaffs_search_end(struct yaffs_search_context *sc) { - if(sc){ - ylist_del(&sc->others); + if (sc) { + list_del(&sc->others); YFREE(sc); } } @@ -441,20 +435,21 @@ static void yaffs_search_end(struct yaffs_search_context * sc) */ static void yaffs_search_advance(struct yaffs_search_context *sc) { - if(!sc) - return; + if (!sc) + return; - if( sc->next_return == NULL || - ylist_empty(&sc->dir_obj->variant.dir_variant.children)) - sc->next_return = NULL; - else { - struct ylist_head *next = sc->next_return->siblings.next; + if (sc->next_return == NULL || + list_empty(&sc->dir_obj->variant.dir_variant.children)) + sc->next_return = NULL; + else { + struct list_head *next = sc->next_return->siblings.next; - if( next == &sc->dir_obj->variant.dir_variant.children) - sc->next_return = NULL; /* end of list */ - else - sc->next_return = ylist_entry(next,yaffs_obj_t,siblings); - } + if (next == &sc->dir_obj->variant.dir_variant.children) + sc->next_return = NULL; /* end of list */ + else + sc->next_return = + list_entry(next, struct yaffs_obj, siblings); + } } /* @@ -462,38 +457,37 @@ static void yaffs_search_advance(struct yaffs_search_context *sc) * We check open search contexts and advance any which are currently * on the object being iterated. */ -static void yaffs_remove_obj_callback(yaffs_obj_t *obj) +static void yaffs_remove_obj_callback(struct yaffs_obj *obj) { - struct ylist_head *i; - struct yaffs_search_context *sc; - struct ylist_head *search_contexts = &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - + struct list_head *i; + struct yaffs_search_context *sc; + struct list_head *search_contexts = + &(yaffs_dev_to_lc(obj->my_dev)->search_contexts); - /* Iterate through the directory search contexts. - * If any are currently on the object being removed, then advance - * the search context to the next object to prevent a hanging pointer. - */ - ylist_for_each(i, search_contexts) { - if (i) { - sc = ylist_entry(i, struct yaffs_search_context,others); - if(sc->next_return == obj) - yaffs_search_advance(sc); - } + /* Iterate through the directory search contexts. + * If any are currently on the object being removed, then advance + * the search context to the next object to prevent a hanging pointer. + */ + list_for_each(i, search_contexts) { + if (i) { + sc = list_entry(i, struct yaffs_search_context, others); + if (sc->next_return == obj) + yaffs_search_advance(sc); + } } } - /*-----------------------------------------------------------------*/ -static int yaffs_readlink(struct dentry *dentry, char __user *buffer, - int buflen) +static int yaffs_readlink(struct dentry *dentry, char __user * buffer, + int buflen) { unsigned char *alias; int ret; - yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -513,7 +507,7 @@ static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd) { unsigned char *alias; void *ret; - yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; yaffs_gross_lock(dev); @@ -531,74 +525,64 @@ out: return ret; } -void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) { +void yaffs_put_link(struct dentry *dentry, struct nameidata *nd, void *alias) +{ kfree(alias); } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_obj_t *obj); + struct yaffs_obj *obj); /* * Lookup is used to find objects in the fs */ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, - struct nameidata *n) + struct nameidata *n) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; struct inode *inode = NULL; /* NCB 2.5/2.6 needs NULL here */ - yaffs_dev_t *dev = yaffs_inode_to_obj(dir)->my_dev; + struct yaffs_dev *dev = yaffs_inode_to_obj(dir)->my_dev; - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup for %d:%s\n"), - yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); + (TSTR("yaffs_lookup for %d:%s\n"), + yaffs_inode_to_obj(dir)->obj_id, dentry->d_name.name)); - obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), - dentry->d_name.name); + obj = yaffs_find_by_name(yaffs_inode_to_obj(dir), dentry->d_name.name); obj = yaffs_get_equivalent_obj(obj); /* in case it was a hardlink */ /* Can't hold gross lock when calling yaffs_get_inode() */ - if(current != yaffs_dev_to_lc(dev)->readdir_process) + if (current != yaffs_dev_to_lc(dev)->readdir_process) yaffs_gross_unlock(dev); if (obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); + (TSTR("yaffs_lookup found %d\n"), obj->obj_id)); inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj); if (inode) { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_loookup dentry \n"))); -/* #if 0 asserted by NCB for 2.5/6 compatability - falls through to - * d_add even if NULL inode */ -#if 0 - /*dget(dentry); // try to solve directory bug */ + T(YAFFS_TRACE_OS, (TSTR("yaffs_loookup dentry \n"))); d_add(dentry, inode); - /* return dentry; */ return NULL; -#endif } } else { - T(YAFFS_TRACE_OS,(TSTR("yaffs_lookup not found\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_lookup not found\n"))); } -/* added NCB for 2.5/6 compatability - forces add even if inode is - * NULL which creates dentry hash */ d_add(dentry, inode); return NULL; } - #ifdef YAFFS_HAS_PUT_INODE /* For now put inode is just for debugging @@ -607,17 +591,16 @@ static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry, static void yaffs_put_inode(struct inode *inode) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, - atomic_read(&inode->i_count))); + (TSTR("yaffs_put_inode: ino %d, count %d\n"), (int)inode->i_ino, + atomic_read(&inode->i_count))); } #endif - -static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj) +static void yaffs_unstitch_obj(struct inode *inode, struct yaffs_obj *obj) { /* Clear the association between the inode and - * the yaffs_obj_t. + * the struct yaffs_obj. */ obj->my_inode = NULL; yaffs_inode_to_obj_lv(inode) = NULL; @@ -633,25 +616,25 @@ static void yaffs_unstitch_obj(struct inode *inode, yaffs_obj_t *obj) * yaffs_clear_inode() and yaffs_delete_inode() * */ -static void yaffs_evict_inode( struct inode *inode) +static void yaffs_evict_inode(struct inode *inode) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; int deleteme = 0; obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, - atomic_read(&inode->i_count), - obj ? "object exists" : "null object")); + (TSTR("yaffs_evict_inode: ino %d, count %d %s\n"), (int)inode->i_ino, + atomic_read(&inode->i_count), + obj ? "object exists" : "null object")); if (!inode->i_nlink && !is_bad_inode(inode)) deleteme = 1; - truncate_inode_pages(&inode->i_data,0); + truncate_inode_pages(&inode->i_data, 0); end_writeback(inode); - if(deleteme && obj){ + if (deleteme && obj) { dev = obj->my_dev; yaffs_gross_lock(dev); yaffs_del_obj(obj); @@ -660,23 +643,21 @@ static void yaffs_evict_inode( struct inode *inode) if (obj) { dev = obj->my_dev; yaffs_gross_lock(dev); - yaffs_unstitch_obj(inode,obj); + yaffs_unstitch_obj(inode, obj); yaffs_gross_unlock(dev); } - } - static int yaffs_file_flush(struct file *file, fl_owner_t id) { - yaffs_obj_t *obj = yaffs_dentry_to_obj(file->f_dentry); + struct yaffs_obj *obj = yaffs_dentry_to_obj(file->f_dentry); - yaffs_dev_t *dev = obj->my_dev; + struct yaffs_dev *dev = obj->my_dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, - obj->dirty ? "dirty" : "clean")); + (TSTR("yaffs_file_flush object %d (%s)\n"), obj->obj_id, + obj->dirty ? "dirty" : "clean")); yaffs_gross_lock(dev); @@ -691,16 +672,16 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) { /* Lifted from jffs2 */ - yaffs_obj_t *obj; + struct yaffs_obj *obj; unsigned char *pg_buf; int ret; - yaffs_dev_t *dev; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), - (unsigned)(pg->index << PAGE_CACHE_SHIFT), - (unsigned)PAGE_CACHE_SIZE)); + (TSTR("yaffs_readpage_nolock at %08x, size %08x\n"), + (unsigned)(pg->index << PAGE_CACHE_SHIFT), + (unsigned)PAGE_CACHE_SIZE)); obj = yaffs_dentry_to_obj(f->f_dentry); @@ -714,8 +695,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) yaffs_gross_lock(dev); ret = yaffs_file_rd(obj, pg_buf, - pg->index << PAGE_CACHE_SHIFT, - PAGE_CACHE_SIZE); + pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE); yaffs_gross_unlock(dev); @@ -749,7 +729,7 @@ static int yaffs_readpage(struct file *f, struct page *pg) int ret; T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage\n"))); - ret=yaffs_readpage_unlock(f, pg); + ret = yaffs_readpage_unlock(f, pg); T(YAFFS_TRACE_OS, (TSTR("yaffs_readpage done\n"))); return ret; } @@ -758,12 +738,12 @@ static int yaffs_readpage(struct file *f, struct page *pg) static int yaffs_writepage(struct page *page, struct writeback_control *wbc) { - yaffs_dev_t *dev; + struct yaffs_dev *dev; struct address_space *mapping = page->mapping; struct inode *inode; unsigned long end_index; char *buffer; - yaffs_obj_t *obj; + struct yaffs_obj *obj; int n_written = 0; unsigned n_bytes; loff_t i_size; @@ -777,20 +757,21 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) end_index = i_size >> PAGE_CACHE_SHIFT; - if(page->index < end_index) + if (page->index < end_index) n_bytes = PAGE_CACHE_SIZE; else { - n_bytes = i_size & (PAGE_CACHE_SIZE -1); + n_bytes = i_size & (PAGE_CACHE_SIZE - 1); if (page->index > end_index || !n_bytes) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, inode size = %08x!!!\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), - (unsigned)inode->i_size)); + (TSTR + ("yaffs_writepage at %08x, inode size = %08x!!!\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), + (unsigned)inode->i_size)); T(YAFFS_TRACE_OS, - (TSTR(" -> don't care!!\n"))); + (TSTR(" -> don't care!!\n"))); - zero_user_segment(page,0,PAGE_CACHE_SIZE); + zero_user_segment(page, 0, PAGE_CACHE_SIZE); set_page_writeback(page); unlock_page(page); end_page_writeback(page); @@ -798,8 +779,8 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) } } - if(n_bytes != PAGE_CACHE_SIZE) - zero_user_segment(page,n_bytes,PAGE_CACHE_SIZE); + if (n_bytes != PAGE_CACHE_SIZE) + zero_user_segment(page, n_bytes, PAGE_CACHE_SIZE); get_page(page); @@ -810,20 +791,20 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) yaffs_gross_lock(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_writepage at %08x, size %08x\n"), - (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); + (TSTR("yaffs_writepage at %08x, size %08x\n"), + (unsigned)(page->index << PAGE_CACHE_SHIFT), n_bytes)); T(YAFFS_TRACE_OS, - (TSTR("writepag0: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag0: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); n_written = yaffs_wr_file(obj, buffer, - page->index << PAGE_CACHE_SHIFT, n_bytes, 0); + page->index << PAGE_CACHE_SHIFT, n_bytes, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("writepag1: obj = %05x, ino = %05x\n"), - (int)obj->variant.file_variant.file_size, (int)inode->i_size)); + (TSTR("writepag1: obj = %05x, ino = %05x\n"), + (int)obj->variant.file_variant.file_size, (int)inode->i_size)); yaffs_gross_unlock(dev); @@ -836,10 +817,9 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) return (n_written == n_bytes) ? 0 : -ENOSPC; } - static int yaffs_write_begin(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned flags, - struct page **pagep, void **fsdata) + loff_t pos, unsigned len, unsigned flags, + struct page **pagep, void **fsdata) { struct page *pg = NULL; pgoff_t index = pos >> PAGE_CACHE_SHIFT; @@ -852,12 +832,12 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, *pagep = pg; if (!pg) { - ret = -ENOMEM; + ret = -ENOMEM; goto out; } T(YAFFS_TRACE_OS, - (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), - (int)index,(int)index,Page_Uptodate(pg) ? 1 : 0)); + (TSTR("start yaffs_write_begin index %d(%x) uptodate %d\n"), + (int)index, (int)index, Page_Uptodate(pg) ? 1 : 0)); /* Get fs space */ space_held = yaffs_hold_space(filp); @@ -882,7 +862,7 @@ static int yaffs_write_begin(struct file *filp, struct address_space *mapping, out: T(YAFFS_TRACE_OS, - (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); + (TSTR("end yaffs_write_begin fail returning %d\n"), ret)); if (space_held) yaffs_release_space(filp); if (pg) { @@ -892,10 +872,9 @@ out: return ret; } - static int yaffs_write_end(struct file *filp, struct address_space *mapping, - loff_t pos, unsigned len, unsigned copied, - struct page *pg, void *fsdadata) + loff_t pos, unsigned len, unsigned copied, + struct page *pg, void *fsdadata) { int ret = 0; void *addr, *kva; @@ -905,15 +884,15 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, addr = kva + offset_into_page; T(YAFFS_TRACE_OS, - ("yaffs_write_end addr %p pos %x n_bytes %d\n", - addr,(unsigned)pos, copied)); + ("yaffs_write_end addr %p pos %x n_bytes %d\n", + addr, (unsigned)pos, copied)); ret = yaffs_file_write(filp, addr, copied, &pos); if (ret != copied) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_write_end not same size ret %d copied %d\n"), - ret, copied)); + (TSTR("yaffs_write_end not same size ret %d copied %d\n"), + ret, copied)); SetPageError(pg); } else { /* Nothing */ @@ -927,14 +906,13 @@ static int yaffs_write_end(struct file *filp, struct address_space *mapping, return ret; } - -static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) +static void yaffs_fill_inode_from_obj(struct inode *inode, + struct yaffs_obj *obj) { if (inode && obj) { - /* Check mode against the variant type and attempt to repair if broken. */ - __u32 mode = obj->yst_mode; + u32 mode = obj->yst_mode; switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: if (!S_ISREG(mode)) { @@ -986,20 +964,21 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) inode->i_nlink = yaffs_get_obj_link_count(obj); T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), - inode->i_mode, inode->i_uid, inode->i_gid, - (int)inode->i_size, atomic_read(&inode->i_count))); + (TSTR + ("yaffs_fill_inode mode %x uid %d gid %d size %d count %d\n"), + inode->i_mode, inode->i_uid, inode->i_gid, + (int)inode->i_size, atomic_read(&inode->i_count))); switch (obj->yst_mode & S_IFMT) { default: /* fifo, device or socket */ init_special_inode(inode, obj->yst_mode, - old_decode_dev(obj->yst_rdev)); + old_decode_dev(obj->yst_rdev)); break; case S_IFREG: /* file */ inode->i_op = &yaffs_file_inode_operations; inode->i_fop = &yaffs_file_operations; inode->i_mapping->a_ops = - &yaffs_file_address_operations; + &yaffs_file_address_operations; break; case S_IFDIR: /* directory */ inode->i_op = &yaffs_dir_inode_operations; @@ -1016,32 +995,32 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, yaffs_obj_t *obj) } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_fill_inode invalid parameters\n"))); + (TSTR("yaffs_fill_inode invalid parameters\n"))); } } struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, - yaffs_obj_t *obj) + struct yaffs_obj *obj) { struct inode *inode; if (!sb) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL super_block!!\n"))); + (TSTR("yaffs_get_inode for NULL super_block!!\n"))); return NULL; } if (!obj) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for NULL object!!\n"))); + (TSTR("yaffs_get_inode for NULL object!!\n"))); return NULL; } T(YAFFS_TRACE_OS, - (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); + (TSTR("yaffs_get_inode for object %d\n"), obj->obj_id)); inode = Y_IGET(sb, obj->obj_id); if (IS_ERR(inode)) @@ -1055,12 +1034,12 @@ struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev, } static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, - loff_t *pos) + loff_t * pos) { - yaffs_obj_t *obj; + struct yaffs_obj *obj; int n_written, ipos; struct inode *inode; - yaffs_dev_t *dev; + struct yaffs_dev *dev; obj = yaffs_dentry_to_obj(f->f_dentry); @@ -1077,20 +1056,20 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, if (!obj) T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: hey obj is null!\n"))); + (TSTR("yaffs_file_write: hey obj is null!\n"))); else T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write about to write writing %u(%x) bytes" + (TSTR("yaffs_file_write about to write writing %u(%x) bytes" "to object %d at %d(%x)\n"), - (unsigned) n, (unsigned) n, obj->obj_id, ipos,ipos)); + (unsigned)n, (unsigned)n, obj->obj_id, ipos, ipos)); n_written = yaffs_wr_file(obj, buf, ipos, n, 0); yaffs_touch_super(dev); T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write: %d(%x) bytes written\n"), - (unsigned )n,(unsigned)n)); + (TSTR("yaffs_file_write: %d(%x) bytes written\n"), + (unsigned)n, (unsigned)n)); if (n_written > 0) { ipos += n_written; @@ -1100,9 +1079,8 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, inode->i_blocks = (ipos + 511) >> 9; T(YAFFS_TRACE_OS, - (TSTR("yaffs_file_write size updated to %d bytes, " - "%d blocks\n"), - ipos, (int)(inode->i_blocks))); + (TSTR("yaffs_file_write size updated to %d bytes, " + "%d blocks\n"), ipos, (int)(inode->i_blocks))); } } @@ -1116,12 +1094,11 @@ static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n, static ssize_t yaffs_hold_space(struct file *f) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; int n_free_chunks; - obj = yaffs_dentry_to_obj(f->f_dentry); dev = obj->my_dev; @@ -1137,9 +1114,8 @@ static ssize_t yaffs_hold_space(struct file *f) static void yaffs_release_space(struct file *f) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; - + struct yaffs_obj *obj; + struct yaffs_dev *dev; obj = yaffs_dentry_to_obj(f->f_dentry); @@ -1147,18 +1123,16 @@ static void yaffs_release_space(struct file *f) yaffs_gross_lock(dev); - yaffs_gross_unlock(dev); } - static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) { long long retval; lock_kernel(); - switch (origin){ + switch (origin) { case 2: offset += i_size_read(file->f_path.dentry->d_inode); break; @@ -1167,7 +1141,7 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) } retval = -EINVAL; - if (offset >= 0){ + if (offset >= 0) { if (offset != file->f_pos) file->f_pos = offset; @@ -1177,16 +1151,15 @@ static loff_t yaffs_dir_llseek(struct file *file, loff_t offset, int origin) return retval; } - static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; - struct yaffs_search_context *sc; + struct yaffs_obj *obj; + struct yaffs_dev *dev; + struct yaffs_search_context *sc; struct inode *inode = f->f_dentry->d_inode; unsigned long offset, curoffs; - yaffs_obj_t *l; - int ret_val = 0; + struct yaffs_obj *l; + int ret_val = 0; char name[YAFFS_MAX_NAME_LENGTH + 1]; @@ -1199,20 +1172,21 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) offset = f->f_pos; - sc = yaffs_new_search(obj); - if(!sc){ - ret_val = -ENOMEM; - goto out; - } + sc = yaffs_new_search(obj); + if (!sc) { + ret_val = -ENOMEM; + goto out; + } - T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); + T(YAFFS_TRACE_OS, + (TSTR("yaffs_readdir: starting at %d\n"), (int)offset)); if (offset == 0) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry . ino %d \n"), - (int)inode->i_ino)); + (TSTR("yaffs_readdir: entry . ino %d \n"), + (int)inode->i_ino)); yaffs_gross_unlock(dev); - if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0){ + if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1222,11 +1196,12 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) } if (offset == 1) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_readdir: entry .. ino %d \n"), - (int)f->f_dentry->d_parent->d_inode->i_ino)); + (TSTR("yaffs_readdir: entry .. ino %d \n"), + (int)f->f_dentry->d_parent->d_inode->i_ino)); yaffs_gross_unlock(dev); if (filldir(dirent, "..", 2, offset, - f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0){ + f->f_dentry->d_parent->d_inode->i_ino, + DT_DIR) < 0) { yaffs_gross_lock(dev); goto out; } @@ -1245,37 +1220,34 @@ static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir) f->f_version = inode->i_version; } - while(sc->next_return){ + while (sc->next_return) { curoffs++; - l = sc->next_return; + l = sc->next_return; if (curoffs >= offset) { - int this_inode = yaffs_get_obj_inode(l); - int this_type = yaffs_get_obj_type(l); + int this_inode = yaffs_get_obj_inode(l); + int this_type = yaffs_get_obj_type(l); - yaffs_get_obj_name(l, name, - YAFFS_MAX_NAME_LENGTH + 1); + yaffs_get_obj_name(l, name, YAFFS_MAX_NAME_LENGTH + 1); T(YAFFS_TRACE_OS, (TSTR("yaffs_readdir: %s inode %d\n"), - name, yaffs_get_obj_inode(l))); + name, yaffs_get_obj_inode(l))); - yaffs_gross_unlock(dev); + yaffs_gross_unlock(dev); if (filldir(dirent, - name, - strlen(name), - offset, - this_inode, - this_type) < 0){ + name, + strlen(name), + offset, this_inode, this_type) < 0) { yaffs_gross_lock(dev); goto out; } - yaffs_gross_lock(dev); + yaffs_gross_lock(dev); offset++; f->f_pos++; } - yaffs_search_advance(sc); + yaffs_search_advance(sc); } out: @@ -1286,8 +1258,6 @@ out: return ret_val; } - - /* * File creation. Allocate an inode, and we're done.. */ @@ -1295,35 +1265,36 @@ out: #define YCRED(x) (x->cred) static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, - dev_t rdev) + dev_t rdev) { struct inode *inode; - yaffs_obj_t *obj = NULL; - yaffs_dev_t *dev; + struct yaffs_obj *obj = NULL; + struct yaffs_dev *dev; - yaffs_obj_t *parent = yaffs_inode_to_obj(dir); + struct yaffs_obj *parent = yaffs_inode_to_obj(dir); int error = -ENOSPC; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; if ((dir->i_mode & S_ISGID) && S_ISDIR(mode)) mode |= S_ISGID; if (parent) { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: parent object %d type %d\n"), - parent->obj_id, parent->variant_type)); + (TSTR("yaffs_mknod: parent object %d type %d\n"), + parent->obj_id, parent->variant_type)); } else { T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: could not get parent object\n"))); + (TSTR("yaffs_mknod: could not get parent object\n"))); return -EPERM; } T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making oject for %s, " - "mode %x dev %x\n"), - dentry->d_name.name, mode, rdev)); + "mode %x dev %x\n"), + dentry->d_name.name, mode, rdev)); dev = parent->my_dev; @@ -1333,19 +1304,19 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, default: /* Special (socket, fifo, device...) */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making special\n"))); - obj = yaffs_create_special(parent, dentry->d_name.name, mode, uid, - gid, old_encode_dev(rdev)); + obj = + yaffs_create_special(parent, dentry->d_name.name, mode, uid, + gid, old_encode_dev(rdev)); break; case S_IFREG: /* file */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making file\n"))); obj = yaffs_create_file(parent, dentry->d_name.name, mode, uid, - gid); + gid); break; case S_IFDIR: /* directory */ - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod: making directory\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making directory\n"))); obj = yaffs_create_dir(parent, dentry->d_name.name, mode, - uid, gid); + uid, gid); break; case S_IFLNK: /* symlink */ T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod: making symlink\n"))); @@ -1361,13 +1332,12 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, d_instantiate(dentry, inode); update_dir_time(dir); T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod created object %d count = %d\n"), - obj->obj_id, atomic_read(&inode->i_count))); + (TSTR("yaffs_mknod created object %d count = %d\n"), + obj->obj_id, atomic_read(&inode->i_count))); error = 0; - yaffs_fill_inode_from_obj(dir,parent); + yaffs_fill_inode_from_obj(dir, parent); } else { - T(YAFFS_TRACE_OS, - (TSTR("yaffs_mknod failed making object\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_mknod failed making object\n"))); error = -ENOMEM; } @@ -1385,7 +1355,7 @@ static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode) static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *n) { - T(YAFFS_TRACE_OS,(TSTR("yaffs_create\n"))); + T(YAFFS_TRACE_OS, (TSTR("yaffs_create\n"))); return yaffs_mknod(dir, dentry, mode | S_IFREG, 0); } @@ -1393,13 +1363,12 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) { int ret_val; - yaffs_dev_t *dev; - yaffs_obj_t *obj; + struct yaffs_dev *dev; + struct yaffs_obj *obj; T(YAFFS_TRACE_OS, - (TSTR("yaffs_unlink %d:%s\n"), - (int)(dir->i_ino), - dentry->d_name.name)); + (TSTR("yaffs_unlink %d:%s\n"), + (int)(dir->i_ino), dentry->d_name.name)); obj = yaffs_inode_to_obj(dir); dev = obj->my_dev; @@ -1423,12 +1392,12 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) * Create a link... */ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, - struct dentry *dentry) + struct dentry *dentry) { struct inode *inode = old_dentry->d_inode; - yaffs_obj_t *obj = NULL; - yaffs_obj_t *link = NULL; - yaffs_dev_t *dev; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *link = NULL; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, (TSTR("yaffs_link\n"))); @@ -1437,23 +1406,24 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, yaffs_gross_lock(dev); - if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ - link = yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, - obj); + if (!S_ISDIR(inode->i_mode)) /* Don't link directories */ + link = + yaffs_link_obj(yaffs_inode_to_obj(dir), dentry->d_name.name, + obj); if (link) { old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj); d_instantiate(dentry, old_dentry->d_inode); atomic_inc(&old_dentry->d_inode->i_count); T(YAFFS_TRACE_OS, - (TSTR("yaffs_link link count %d i_count %d\n"), - old_dentry->d_inode->i_nlink, - atomic_read(&old_dentry->d_inode->i_count))); + (TSTR("yaffs_link link count %d i_count %d\n"), + old_dentry->d_inode->i_nlink, + atomic_read(&old_dentry->d_inode->i_count))); } yaffs_gross_unlock(dev); - if (link){ + if (link) { update_dir_time(dir); return 0; } @@ -1462,19 +1432,20 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, } static int yaffs_symlink(struct inode *dir, struct dentry *dentry, - const char *symname) + const char *symname) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; uid_t uid = YCRED(current)->fsuid; - gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; + gid_t gid = + (dir->i_mode & S_ISGID) ? dir->i_gid : YCRED(current)->fsgid; T(YAFFS_TRACE_OS, (TSTR("yaffs_symlink\n"))); dev = yaffs_inode_to_obj(dir)->my_dev; yaffs_gross_lock(dev); obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name, - S_IFLNK | S_IRWXUGO, uid, gid, symname); + S_IFLNK | S_IRWXUGO, uid, gid, symname); yaffs_gross_unlock(dev); if (obj) { @@ -1495,16 +1466,15 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry, static int yaffs_sync_object(struct file *file, int datasync) { - yaffs_obj_t *obj; - yaffs_dev_t *dev; + struct yaffs_obj *obj; + struct yaffs_dev *dev; struct dentry *dentry = file->f_path.dentry; obj = yaffs_dentry_to_obj(dentry); dev = obj->my_dev; - T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_object\n"))); + T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, (TSTR("yaffs_sync_object\n"))); yaffs_gross_lock(dev); yaffs_flush_file(obj, 1, datasync); yaffs_gross_unlock(dev); @@ -1519,9 +1489,9 @@ static int yaffs_sync_object(struct file *file, int datasync) static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { - yaffs_dev_t *dev; + struct yaffs_dev *dev; int ret_val = YAFFS_FAIL; - yaffs_obj_t *target; + struct yaffs_obj *target; T(YAFFS_TRACE_OS, (TSTR("yaffs_rename\n"))); dev = yaffs_inode_to_obj(old_dir)->my_dev; @@ -1530,12 +1500,10 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, /* Check if the target is an existing directory that is not empty. */ target = yaffs_find_by_name(yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); - - + new_dentry->d_name.name); if (target && target->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY && - !ylist_empty(&target->variant.dir_variant.children)) { + !list_empty(&target->variant.dir_variant.children)) { T(YAFFS_TRACE_OS, (TSTR("target is non-empty dir\n"))); @@ -1545,9 +1513,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, T(YAFFS_TRACE_OS, (TSTR("calling yaffs_rename_obj\n"))); ret_val = yaffs_rename_obj(yaffs_inode_to_obj(old_dir), - old_dentry->d_name.name, - yaffs_inode_to_obj(new_dir), - new_dentry->d_name.name); + old_dentry->d_name.name, + yaffs_inode_to_obj(new_dir), + new_dentry->d_name.name); } yaffs_gross_unlock(dev); @@ -1556,9 +1524,9 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, new_dentry->d_inode->i_nlink--; mark_inode_dirty(new_dentry->d_inode); } - + update_dir_time(old_dir); - if(old_dir != new_dir) + if (old_dir != new_dir) update_dir_time(new_dir); return 0; } else { @@ -1570,37 +1538,37 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; + struct yaffs_dev *dev; T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr of object %d\n"), - yaffs_inode_to_obj(inode)->obj_id)); + (TSTR("yaffs_setattr of object %d\n"), + yaffs_inode_to_obj(inode)->obj_id)); - /* Fail if a requested resize >= 2GB */ - if (attr->ia_valid & ATTR_SIZE && - (attr->ia_size >> 31)) + /* Fail if a requested resize >= 2GB */ + if (attr->ia_valid & ATTR_SIZE && (attr->ia_size >> 31)) error = -EINVAL; if (error == 0) error = inode_change_ok(inode, attr); if (error == 0) { int result; - if (!error){ + if (!error) { error = yaffs_vfs_setattr(inode, attr); - T(YAFFS_TRACE_OS,(TSTR("inode_setattr called\n"))); - if (attr->ia_valid & ATTR_SIZE){ - yaffs_vfs_setsize(inode,attr->ia_size); - inode->i_blocks = (inode->i_size + 511) >> 9; + T(YAFFS_TRACE_OS, (TSTR("inode_setattr called\n"))); + if (attr->ia_valid & ATTR_SIZE) { + yaffs_vfs_setsize(inode, attr->ia_size); + inode->i_blocks = (inode->i_size + 511) >> 9; } } dev = yaffs_inode_to_obj(inode)->my_dev; - if (attr->ia_valid & ATTR_SIZE){ - T(YAFFS_TRACE_OS,(TSTR("resize to %d(%x)\n"), - (int)(attr->ia_size),(int)(attr->ia_size))); + if (attr->ia_valid & ATTR_SIZE) { + T(YAFFS_TRACE_OS, (TSTR("resize to %d(%x)\n"), + (int)(attr->ia_size), + (int)(attr->ia_size))); } yaffs_gross_lock(dev); result = yaffs_set_attribs(yaffs_inode_to_obj(inode), attr); - if(result == YAFFS_OK) { + if (result == YAFFS_OK) { error = 0; } else { error = -EPERM; @@ -1609,56 +1577,49 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setattr done returning %d\n"), error)); return error; } #ifdef CONFIG_YAFFS_XATTR int yaffs_setxattr(struct dentry *dentry, const char *name, - const void *value, size_t size, int flags) + const void *value, size_t size, int flags) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); - - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr of object %d\n"), - obj->obj_id)); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_set_xattrib(obj, name, value, size, flags); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_setxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_setxattr done returning %d\n"), error)); return error; } - -ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, - size_t size) +ssize_t yaffs_getxattr(struct dentry * dentry, const char *name, void *buff, + size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr \"%s\" from object %d\n"), - name, obj->obj_id)); + (TSTR("yaffs_getxattr \"%s\" from object %d\n"), name, obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -1667,8 +1628,7 @@ ssize_t yaffs_getxattr(struct dentry *dentry, const char *name, void *buff, yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_getxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_getxattr done returning %d\n"), error)); return error; } @@ -1677,43 +1637,39 @@ int yaffs_removexattr(struct dentry *dentry, const char *name) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_removexattr of object %d\n"), obj->obj_id)); if (error == 0) { int result; dev = obj->my_dev; yaffs_gross_lock(dev); result = yaffs_remove_xattrib(obj, name); - if(result == YAFFS_OK) + if (result == YAFFS_OK) error = 0; - else if(result < 0) + else if (result < 0) error = result; yaffs_gross_unlock(dev); } T(YAFFS_TRACE_OS, - (TSTR("yaffs_removexattr done returning %d\n"),error)); + (TSTR("yaffs_removexattr done returning %d\n"), error)); return error; } -ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) +ssize_t yaffs_listxattr(struct dentry * dentry, char *buff, size_t size) { struct inode *inode = dentry->d_inode; int error = 0; - yaffs_dev_t *dev; - yaffs_obj_t *obj = yaffs_inode_to_obj(inode); + struct yaffs_dev *dev; + struct yaffs_obj *obj = yaffs_inode_to_obj(inode); T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr of object %d\n"), - obj->obj_id)); - + (TSTR("yaffs_listxattr of object %d\n"), obj->obj_id)); if (error == 0) { dev = obj->my_dev; @@ -1722,18 +1678,16 @@ ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) yaffs_gross_unlock(dev); } - T(YAFFS_TRACE_OS, - (TSTR("yaffs_listxattr done returning %d\n"),error)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_listxattr done returning %d\n"), error)); return error; } #endif - static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) { - yaffs_dev_t *dev = yaffs_dentry_to_obj(dentry)->my_dev; + struct yaffs_dev *dev = yaffs_dentry_to_obj(dentry)->my_dev; struct super_block *sb = dentry->d_sb; T(YAFFS_TRACE_OS, (TSTR("yaffs_statfs\n"))); @@ -1750,14 +1704,17 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) uint64_t bytes_in_dev; uint64_t bytes_free; - bytes_in_dev = ((uint64_t)((dev->param.end_block - dev->param.start_block + 1))) * - ((uint64_t)(dev->param.chunks_per_block * dev->data_bytes_per_chunk)); + bytes_in_dev = + ((uint64_t) + ((dev->param.end_block - dev->param.start_block + + 1))) * ((uint64_t) (dev->param.chunks_per_block * + dev->data_bytes_per_chunk)); - do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ + do_div(bytes_in_dev, sb->s_blocksize); /* bytes_in_dev becomes the number of blocks */ buf->f_blocks = bytes_in_dev; - bytes_free = ((uint64_t)(yaffs_get_n_free_chunks(dev))) * - ((uint64_t)(dev->data_bytes_per_chunk)); + bytes_free = ((uint64_t) (yaffs_get_n_free_chunks(dev))) * + ((uint64_t) (dev->data_bytes_per_chunk)); do_div(bytes_free, sb->s_blocksize); @@ -1766,21 +1723,21 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) } else if (sb->s_blocksize > dev->data_bytes_per_chunk) { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block / - (sb->s_blocksize / dev->data_bytes_per_chunk); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block / + (sb->s_blocksize / dev->data_bytes_per_chunk); buf->f_bfree = - yaffs_get_n_free_chunks(dev) / - (sb->s_blocksize / dev->data_bytes_per_chunk); + yaffs_get_n_free_chunks(dev) / + (sb->s_blocksize / dev->data_bytes_per_chunk); } else { buf->f_blocks = - (dev->param.end_block - dev->param.start_block + 1) * - dev->param.chunks_per_block * - (dev->data_bytes_per_chunk / sb->s_blocksize); + (dev->param.end_block - dev->param.start_block + 1) * + dev->param.chunks_per_block * + (dev->data_bytes_per_chunk / sb->s_blocksize); buf->f_bfree = - yaffs_get_n_free_chunks(dev) * - (dev->data_bytes_per_chunk / sb->s_blocksize); + yaffs_get_n_free_chunks(dev) * + (dev->data_bytes_per_chunk / sb->s_blocksize); } buf->f_files = 0; @@ -1791,84 +1748,79 @@ static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf) return 0; } - - static void yaffs_flush_inodes(struct super_block *sb) { struct inode *iptr; - yaffs_obj_t *obj; - - list_for_each_entry(iptr,&sb->s_inodes, i_sb_list){ + struct yaffs_obj *obj; + + list_for_each_entry(iptr, &sb->s_inodes, i_sb_list) { obj = yaffs_inode_to_obj(iptr); - if(obj){ + if (obj) { T(YAFFS_TRACE_OS, (TSTR("flushing obj %d\n"), - obj->obj_id)); - yaffs_flush_file(obj,1,0); + obj->obj_id)); + yaffs_flush_file(obj, 1, 0); } } } - static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); - if(!dev) + struct yaffs_dev *dev = yaffs_super_to_dev(sb); + if (!dev) return; - + yaffs_flush_inodes(sb); yaffs_update_dirty_dirs(dev); yaffs_flush_whole_cache(dev); - if(do_checkpoint) + if (do_checkpoint) yaffs_checkpoint_save(dev); } - -static unsigned yaffs_bg_gc_urgency(yaffs_dev_t *dev) +static unsigned yaffs_bg_gc_urgency(struct yaffs_dev *dev) { - unsigned erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + unsigned erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - unsigned scattered = 0; /* Free chunks not in an erased block */ + unsigned scattered = 0; /* Free chunks not in an erased block */ - if(erased_chunks < dev->n_free_chunks) + if (erased_chunks < dev->n_free_chunks) scattered = (dev->n_free_chunks - erased_chunks); - if(!context->bg_running) + if (!context->bg_running) return 0; - else if(scattered < (dev->param.chunks_per_block * 2)) + else if (scattered < (dev->param.chunks_per_block * 2)) return 0; - else if(erased_chunks > dev->n_free_chunks/2) + else if (erased_chunks > dev->n_free_chunks / 2) return 0; - else if(erased_chunks > dev->n_free_chunks/4) + else if (erased_chunks > dev->n_free_chunks / 4) return 1; else return 2; } -static int yaffs_do_sync_fs(struct super_block *sb, - int request_checkpoint) +static int yaffs_do_sync_fs(struct super_block *sb, int request_checkpoint) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); unsigned int oneshot_checkpoint = (yaffs_auto_checkpoint & 4); unsigned gc_urgent = yaffs_bg_gc_urgency(dev); int do_checkpoint; T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), - gc_urgent, - sb->s_dirt ? "dirty" : "clean", - request_checkpoint ? "checkpoint requested" : "no checkpoint", - oneshot_checkpoint ? " one-shot" : "" )); + (TSTR("yaffs_do_sync_fs: gc-urgency %d %s %s%s\n"), + gc_urgent, + sb->s_dirt ? "dirty" : "clean", + request_checkpoint ? "checkpoint requested" : "no checkpoint", + oneshot_checkpoint ? " one-shot" : "")); yaffs_gross_lock(dev); do_checkpoint = ((request_checkpoint && !gc_urgent) || - oneshot_checkpoint) && - !dev->is_checkpointed; + oneshot_checkpoint) && !dev->is_checkpointed; if (sb->s_dirt || do_checkpoint) { yaffs_flush_super(sb, !dev->is_checkpointed && do_checkpoint); sb->s_dirt = 0; - if(oneshot_checkpoint) + if (oneshot_checkpoint) yaffs_auto_checkpoint &= ~4; } yaffs_gross_unlock(dev); @@ -1888,7 +1840,6 @@ static int yaffs_do_sync_fs(struct super_block *sb, * The thread should not do any writing while the fs is in read only. */ - void yaffs_background_waker(unsigned long data) { wake_up_process((struct task_struct *)data); @@ -1896,7 +1847,7 @@ void yaffs_background_waker(unsigned long data) static int yaffs_bg_thread_fn(void *data) { - yaffs_dev_t *dev = (yaffs_dev_t *)data; + struct yaffs_dev *dev = (struct yaffs_dev *)data; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); unsigned long now = jiffies; unsigned long next_dir_update = now; @@ -1908,58 +1859,56 @@ static int yaffs_bg_thread_fn(void *data) struct timer_list timer; T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background starting for dev %p\n"), - (void *)dev)); + (TSTR("yaffs_background starting for dev %p\n"), (void *)dev)); set_freezable(); - while(context->bg_running){ - T(YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_background\n"))); + while (context->bg_running) { + T(YAFFS_TRACE_BACKGROUND, (TSTR("yaffs_background\n"))); - if(kthread_should_stop()) + if (kthread_should_stop()) break; - if(try_to_freeze()) + if (try_to_freeze()) continue; yaffs_gross_lock(dev); now = jiffies; - if(time_after(now, next_dir_update) && yaffs_bg_enable){ + if (time_after(now, next_dir_update) && yaffs_bg_enable) { yaffs_update_dirty_dirs(dev); next_dir_update = now + HZ; } - if(time_after(now,next_gc) && yaffs_bg_enable){ - if(!dev->is_checkpointed){ + if (time_after(now, next_gc) && yaffs_bg_enable) { + if (!dev->is_checkpointed) { urgency = yaffs_bg_gc_urgency(dev); gc_result = yaffs_bg_gc(dev, urgency); - if(urgency > 1) - next_gc = now + HZ/20+1; - else if(urgency > 0) - next_gc = now + HZ/10+1; + if (urgency > 1) + next_gc = now + HZ / 20 + 1; + else if (urgency > 0) + next_gc = now + HZ / 10 + 1; else next_gc = now + HZ * 2; - } else /* - * gc not running so set to next_dir_update - * to cut down on wake ups - */ + } else /* + * gc not running so set to next_dir_update + * to cut down on wake ups + */ next_gc = next_dir_update; } yaffs_gross_unlock(dev); expires = next_dir_update; - if (time_before(next_gc,expires)) + if (time_before(next_gc, expires)) expires = next_gc; - if(time_before(expires,now)) + if (time_before(expires, now)) expires = now + HZ; Y_INIT_TIMER(&timer); - timer.expires = expires+1; - timer.data = (unsigned long) current; + timer.expires = expires + 1; + timer.data = (unsigned long)current; timer.function = yaffs_background_waker; - set_current_state(TASK_INTERRUPTIBLE); + set_current_state(TASK_INTERRUPTIBLE); add_timer(&timer); schedule(); del_timer_sync(&timer); @@ -1968,20 +1917,21 @@ static int yaffs_bg_thread_fn(void *data) return 0; } -static int yaffs_bg_start(yaffs_dev_t *dev) +static int yaffs_bg_start(struct yaffs_dev *dev) { int retval = 0; struct yaffs_linux_context *context = yaffs_dev_to_lc(dev); - if(dev->read_only) + if (dev->read_only) return -1; context->bg_running = 1; context->bg_thread = kthread_run(yaffs_bg_thread_fn, - (void *)dev,"yaffs-bg-%d",context->mount_id); + (void *)dev, "yaffs-bg-%d", + context->mount_id); - if(IS_ERR(context->bg_thread)){ + if (IS_ERR(context->bg_thread)) { retval = PTR_ERR(context->bg_thread); context->bg_thread = NULL; context->bg_running = 0; @@ -1989,39 +1939,36 @@ static int yaffs_bg_start(yaffs_dev_t *dev) return retval; } -static void yaffs_bg_stop(yaffs_dev_t *dev) +static void yaffs_bg_stop(struct yaffs_dev *dev) { struct yaffs_linux_context *ctxt = yaffs_dev_to_lc(dev); ctxt->bg_running = 0; - if( ctxt->bg_thread){ + if (ctxt->bg_thread) { kthread_stop(ctxt->bg_thread); ctxt->bg_thread = NULL; } } - static void yaffs_write_super(struct super_block *sb) { unsigned request_checkpoint = (yaffs_auto_checkpoint >= 2); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs_write_super%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_write_super%s\n"), + request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); } - static int yaffs_sync_fs(struct super_block *sb, int wait) { unsigned request_checkpoint = (yaffs_auto_checkpoint >= 1); T(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, - (TSTR("yaffs_sync_fs%s\n"), - request_checkpoint ? " checkpt" : "")); + (TSTR("yaffs_sync_fs%s\n"), request_checkpoint ? " checkpt" : "")); yaffs_do_sync_fs(sb, request_checkpoint); @@ -2031,11 +1978,10 @@ static int yaffs_sync_fs(struct super_block *sb, int wait) static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) { struct inode *inode; - yaffs_obj_t *obj; - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_obj *obj; + struct yaffs_dev *dev = yaffs_super_to_dev(sb); - T(YAFFS_TRACE_OS, - (TSTR("yaffs_iget for %lu\n"), ino)); + T(YAFFS_TRACE_OS, (TSTR("yaffs_iget for %lu\n"), ino)); inode = iget_locked(sb, ino); if (!inode) @@ -2060,36 +2006,34 @@ static struct inode *yaffs_iget(struct super_block *sb, unsigned long ino) return inode; } -static YLIST_HEAD(yaffs_context_list); -struct semaphore yaffs_context_lock; +static LIST_HEAD(yaffs_context_list); +struct mutex yaffs_context_lock; static void yaffs_put_super(struct super_block *sb) { - yaffs_dev_t *dev = yaffs_super_to_dev(sb); + struct yaffs_dev *dev = yaffs_super_to_dev(sb); T(YAFFS_TRACE_OS, (TSTR("yaffs_put_super\n"))); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("Shutting down yaffs background thread\n"))); + (TSTR("Shutting down yaffs background thread\n"))); yaffs_bg_stop(dev); T(YAFFS_TRACE_OS | YAFFS_TRACE_BACKGROUND, - (TSTR("yaffs background thread shut down\n"))); + (TSTR("yaffs background thread shut down\n"))); yaffs_gross_lock(dev); - yaffs_flush_super(sb,1); + yaffs_flush_super(sb, 1); if (yaffs_dev_to_lc(dev)->put_super_fn) yaffs_dev_to_lc(dev)->put_super_fn(sb); - yaffs_deinitialise(dev); yaffs_gross_unlock(dev); - - down(&yaffs_context_lock); - ylist_del_init(&(yaffs_dev_to_lc(dev)->context_list)); - up(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); + list_del_init(&(yaffs_dev_to_lc(dev)->context_list)); + mutex_unlock(&yaffs_context_lock); if (yaffs_dev_to_lc(dev)->spare_buffer) { YFREE(yaffs_dev_to_lc(dev)->spare_buffer); @@ -2099,7 +2043,6 @@ static void yaffs_put_super(struct super_block *sb) kfree(dev); } - static void yaffs_mtd_put_super(struct super_block *sb) { struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb)); @@ -2110,8 +2053,7 @@ static void yaffs_mtd_put_super(struct super_block *sb) put_mtd_device(mtd); } - -static void yaffs_touch_super(yaffs_dev_t *dev) +static void yaffs_touch_super(struct yaffs_dev *dev) { struct super_block *sb = yaffs_dev_to_lc(dev)->super; @@ -2120,7 +2062,7 @@ static void yaffs_touch_super(yaffs_dev_t *dev) sb->s_dirt = 1; } -typedef struct { +struct yaffs_options { int inband_tags; int skip_checkpoint_read; int skip_checkpoint_write; @@ -2131,10 +2073,11 @@ typedef struct { int lazy_loading_overridden; int empty_lost_and_found; int empty_lost_and_found_overridden; -} yaffs_options; +}; #define MAX_OPT_LEN 30 -static int yaffs_parse_options(yaffs_options *options, const char *options_str) +static int yaffs_parse_options(struct yaffs_options *options, + const char *options_str) { char cur_opt[MAX_OPT_LEN + 1]; int p; @@ -2146,7 +2089,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) memset(cur_opt, 0, MAX_OPT_LEN + 1); p = 0; - while(*options_str == ',') + while (*options_str == ',') options_str++; while (*options_str && *options_str != ',') { @@ -2159,24 +2102,24 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) if (!strcmp(cur_opt, "inband-tags")) options->inband_tags = 1; - else if (!strcmp(cur_opt, "tags-ecc-off")){ + else if (!strcmp(cur_opt, "tags-ecc-off")) { options->tags_ecc_on = 0; - options->tags_ecc_overridden=1; - } else if (!strcmp(cur_opt, "tags-ecc-on")){ + options->tags_ecc_overridden = 1; + } else if (!strcmp(cur_opt, "tags-ecc-on")) { options->tags_ecc_on = 1; options->tags_ecc_overridden = 1; - } else if (!strcmp(cur_opt, "lazy-loading-off")){ + } else if (!strcmp(cur_opt, "lazy-loading-off")) { options->lazy_loading_enabled = 0; - options->lazy_loading_overridden=1; - } else if (!strcmp(cur_opt, "lazy-loading-on")){ + options->lazy_loading_overridden = 1; + } else if (!strcmp(cur_opt, "lazy-loading-on")) { options->lazy_loading_enabled = 1; options->lazy_loading_overridden = 1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-off")){ + } else if (!strcmp(cur_opt, "empty-lost-and-found-off")) { options->empty_lost_and_found = 0; - options->empty_lost_and_found_overridden=1; - } else if (!strcmp(cur_opt, "empty-lost-and-found-on")){ + options->empty_lost_and_found_overridden = 1; + } else if (!strcmp(cur_opt, "empty-lost-and-found-on")) { options->empty_lost_and_found = 1; - options->empty_lost_and_found_overridden=1; + options->empty_lost_and_found_overridden = 1; } else if (!strcmp(cur_opt, "no-cache")) options->no_cache = 1; else if (!strcmp(cur_opt, "no-checkpoint-read")) @@ -2188,7 +2131,7 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) options->skip_checkpoint_write = 1; } else { printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n", - cur_opt); + cur_opt); error = 1; } } @@ -2197,34 +2140,34 @@ static int yaffs_parse_options(yaffs_options *options, const char *options_str) } static struct super_block *yaffs_internal_read_super(int yaffs_version, - struct super_block *sb, - void *data, int silent) + struct super_block *sb, + void *data, int silent) { - int nBlocks; + int n_blocks; struct inode *inode = NULL; struct dentry *root; - yaffs_dev_t *dev = 0; + struct yaffs_dev *dev = 0; char devname_buf[BDEVNAME_SIZE + 1]; struct mtd_info *mtd; int err; char *data_str = (char *)data; struct yaffs_linux_context *context = NULL; - yaffs_param_t *param; + struct yaffs_param *param; int read_only = 0; - yaffs_options options; + struct yaffs_options options; unsigned mount_id; int found; struct yaffs_linux_context *context_iterator; - struct ylist_head *l; + struct list_head *l; sb->s_magic = YAFFS_MAGIC; sb->s_op = &yaffs_super_ops; sb->s_flags |= MS_NOATIME; - read_only =((sb->s_flags & MS_RDONLY) != 0); + read_only = ((sb->s_flags & MS_RDONLY) != 0); sb->s_export_op = &yaffs_export_ops; @@ -2237,8 +2180,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, else printk(KERN_INFO "yaffs: dev is %d name is \"%s\" %s\n", sb->s_dev, - yaffs_devname(sb, devname_buf), - read_only ? "ro" : "rw"); + yaffs_devname(sb, devname_buf), read_only ? "ro" : "rw"); if (!data_str) data_str = ""; @@ -2252,20 +2194,17 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, return NULL; } - sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); + (TSTR("yaffs_read_super: Using yaffs%d\n"), yaffs_version)); T(YAFFS_TRACE_OS, - (TSTR("yaffs_read_super: block size %d\n"), - (int)(sb->s_blocksize))); + (TSTR("yaffs_read_super: block size %d\n"), (int)(sb->s_blocksize))); T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), - MAJOR(sb->s_dev), MINOR(sb->s_dev), - yaffs_devname(sb, devname_buf))); + (TSTR("yaffs: Attempting MTD mount of %u.%u,\"%s\"\n"), + MAJOR(sb->s_dev), MINOR(sb->s_dev), yaffs_devname(sb, devname_buf))); /* Check it's an mtd device..... */ if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) @@ -2275,15 +2214,15 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); if (!mtd) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), - MINOR(sb->s_dev))); + (TSTR("yaffs: MTD device #%u doesn't appear to exist\n"), + MINOR(sb->s_dev))); return NULL; } /* Check it's NAND */ if (mtd->type != MTD_NANDFLASH) { T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: MTD device is not NAND it's type %d\n"), - mtd->type)); + (TSTR("yaffs: MTD device is not NAND it's type %d\n"), + mtd->type)); return NULL; } @@ -2302,18 +2241,16 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_AUTO_YAFFS2 if (yaffs_version == 1 && WRITE_SIZE(mtd) >= 2048) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs2\n"))); + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs2\n"))); yaffs_version = 2; } /* Added NCB 26/5/2006 for completeness */ - if (yaffs_version == 2 && !options.inband_tags && WRITE_SIZE(mtd) == 512) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: auto selecting yaffs1\n"))); + if (yaffs_version == 2 && !options.inband_tags + && WRITE_SIZE(mtd) == 512) { + T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: auto selecting yaffs1\n"))); yaffs_version = 1; } - #endif if (yaffs_version == 2) { @@ -2322,31 +2259,29 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, !mtd->block_isbad || !mtd->block_markbad || !mtd->read || - !mtd->write || - !mtd->read_oob || !mtd->write_oob) { + !mtd->write || !mtd->read_oob || !mtd->write_oob) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE || - mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && + mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) && !options.inband_tags) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } else { /* Check for V1 style functions */ if (!mtd->erase || !mtd->read || - !mtd->write || - !mtd->read_oob || !mtd->write_oob) { + !mtd->write || !mtd->read_oob || !mtd->write_oob) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support required " - "functions\n"))); + "functions\n"))); return NULL; } @@ -2354,29 +2289,30 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, mtd->oobsize != YAFFS_BYTES_PER_SPARE) { T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: MTD device does not support have the " - "right page sizes\n"))); + "right page sizes\n"))); return NULL; } } /* OK, so if we got here, we have an MTD that's NAND and looks * like it has the right capabilities - * Set the yaffs_dev_t up for mtd + * Set the struct yaffs_dev up for mtd */ - if (!read_only && !(mtd->flags & MTD_WRITEABLE)){ + if (!read_only && !(mtd->flags & MTD_WRITEABLE)) { read_only = 1; - printk(KERN_INFO "yaffs: mtd is read only, setting superblock read only"); + printk(KERN_INFO + "yaffs: mtd is read only, setting superblock read only"); sb->s_flags |= MS_RDONLY; } - dev = kmalloc(sizeof(yaffs_dev_t), GFP_KERNEL); - context = kmalloc(sizeof(struct yaffs_linux_context),GFP_KERNEL); - - if(!dev || !context ){ - if(dev) + dev = kmalloc(sizeof(struct yaffs_dev), GFP_KERNEL); + context = kmalloc(sizeof(struct yaffs_linux_context), GFP_KERNEL); + + if (!dev || !context) { + if (dev) kfree(dev); - if(context) + if (context) kfree(context); dev = NULL; context = NULL; @@ -2386,31 +2322,33 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Deep shit could not allocate device structure */ T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs_read_super: Failed trying to allocate " - "yaffs_dev_t. \n"))); + "struct yaffs_dev. \n"))); return NULL; } - memset(dev, 0, sizeof(yaffs_dev_t)); + memset(dev, 0, sizeof(struct yaffs_dev)); param = &(dev->param); - memset(context,0,sizeof(struct yaffs_linux_context)); + memset(context, 0, sizeof(struct yaffs_linux_context)); dev->os_context = context; - YINIT_LIST_HEAD(&(context->context_list)); + INIT_LIST_HEAD(&(context->context_list)); context->dev = dev; context->super = sb; dev->read_only = read_only; sb->s_fs_info = dev; - + dev->driver_context = mtd; param->name = mtd->name; /* Set up the memory size parameters.... */ - nBlocks = YCALCBLOCKS(mtd->size, (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); + n_blocks = + YCALCBLOCKS(mtd->size, + (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK)); param->start_block = 0; - param->end_block = nBlocks - 1; + param->end_block = n_blocks - 1; param->chunks_per_block = YAFFS_CHUNKS_PER_BLOCK; param->total_bytes_per_chunk = YAFFS_BYTES_PER_CHUNK; param->n_reserved_blocks = 5; @@ -2423,7 +2361,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, #ifdef CONFIG_YAFFS_XATTR param->enable_xattr = 1; #endif - if(options.lazy_loading_overridden) + if (options.lazy_loading_overridden) param->disable_lazy_load = !options.lazy_loading_enabled; #ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC @@ -2435,7 +2373,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->defered_dir_update = 1; #endif - if(options.tags_ecc_overridden) + if (options.tags_ecc_overridden) param->no_tags_ecc = !options.tags_ecc_on; #ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND @@ -2452,31 +2390,27 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->always_check_erased = 1; #endif - if(options.empty_lost_and_found_overridden) + if (options.empty_lost_and_found_overridden) param->empty_lost_n_found = options.empty_lost_and_found; /* ... and the functions. */ if (yaffs_version == 2) { - param->write_chunk_tags_fn = - nandmtd2_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd2_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd2_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd2_read_chunk_tags; param->bad_block_fn = nandmtd2_mark_block_bad; param->query_block_fn = nandmtd2_query_block; yaffs_dev_to_lc(dev)->spare_buffer = YMALLOC(mtd->oobsize); param->is_yaffs2 = 1; param->total_bytes_per_chunk = mtd->writesize; param->chunks_per_block = mtd->erasesize / mtd->writesize; - nBlocks = YCALCBLOCKS(mtd->size, mtd->erasesize); + n_blocks = YCALCBLOCKS(mtd->size, mtd->erasesize); param->start_block = 0; - param->end_block = nBlocks - 1; + param->end_block = n_blocks - 1; } else { /* use the MTD interface in yaffs_mtdif1.c */ - param->write_chunk_tags_fn = - nandmtd1_write_chunk_tags; - param->read_chunk_tags_fn = - nandmtd1_read_chunk_tags; + param->write_chunk_tags_fn = nandmtd1_write_chunk_tags; + param->read_chunk_tags_fn = nandmtd1_read_chunk_tags; param->bad_block_fn = nandmtd1_mark_block_bad; param->query_block_fn = nandmtd1_query_block; param->is_yaffs2 = 0; @@ -2490,8 +2424,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->sb_dirty_fn = yaffs_touch_super; param->gc_control = yaffs_gc_control_callback; - yaffs_dev_to_lc(dev)->super= sb; - + yaffs_dev_to_lc(dev)->super = sb; #ifndef CONFIG_YAFFS_DOES_ECC param->use_nand_ecc = 1; @@ -2504,27 +2437,30 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->skip_checkpt_rd = options.skip_checkpoint_read; param->skip_checkpt_wr = options.skip_checkpoint_write; - down(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); /* Get a mount id */ found = 0; - for(mount_id=0; ! found; mount_id++){ + for (mount_id = 0; !found; mount_id++) { found = 1; - ylist_for_each(l,&yaffs_context_list){ - context_iterator = ylist_entry(l,struct yaffs_linux_context,context_list); - if(context_iterator->mount_id == mount_id) + list_for_each(l, &yaffs_context_list) { + context_iterator = + list_entry(l, struct yaffs_linux_context, + context_list); + if (context_iterator->mount_id == mount_id) found = 0; } } context->mount_id = mount_id; - ylist_add_tail(&(yaffs_dev_to_lc(dev)->context_list), &yaffs_context_list); - up(&yaffs_context_lock); + list_add_tail(&(yaffs_dev_to_lc(dev)->context_list), + &yaffs_context_list); + mutex_unlock(&yaffs_context_lock); - /* Directory search handling...*/ - YINIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); - param->remove_obj_fn = yaffs_remove_obj_callback; + /* Directory search handling... */ + INIT_LIST_HEAD(&(yaffs_dev_to_lc(dev)->search_contexts)); + param->remove_obj_fn = yaffs_remove_obj_callback; - init_MUTEX(&(yaffs_dev_to_lc(dev)->gross_lock)); + mutex_init(&(yaffs_dev_to_lc(dev)->gross_lock)); yaffs_gross_lock(dev); @@ -2533,21 +2469,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: guts initialised %s\n"), (err == YAFFS_OK) ? "OK" : "FAILED")); - - if(err == YAFFS_OK) + + if (err == YAFFS_OK) yaffs_bg_start(dev); - - if(!context->bg_thread) - param->defered_dir_update = 0; + if (!context->bg_thread) + param->defered_dir_update = 0; /* Release lock before yaffs_get_inode() */ yaffs_gross_unlock(dev); /* Create root inode */ if (err == YAFFS_OK) - inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, - yaffs_root(dev)); + inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0, yaffs_root(dev)); if (!inode) return NULL; @@ -2568,14 +2502,13 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, sb->s_root = root; sb->s_dirt = !dev->is_checkpointed; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_read_super: is_checkpointed %d\n"), - dev->is_checkpointed)); + (TSTR("yaffs_read_super: is_checkpointed %d\n"), + dev->is_checkpointed)); T(YAFFS_TRACE_OS, (TSTR("yaffs_read_super: done\n"))); return sb; } - static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data, int silent) { @@ -2599,7 +2532,6 @@ static struct file_system_type yaffs_fs_type = { .fs_flags = FS_REQUIRES_DEV, }; - #ifdef CONFIG_YAFFS_YAFFS2 static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, @@ -2609,11 +2541,11 @@ static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, } static int yaffs2_read_super(struct file_system_type *fs, - int flags, const char *dev_name, void *data, - struct vfsmount *mnt) + int flags, const char *dev_name, void *data, + struct vfsmount *mnt) { return get_sb_bdev(fs, flags, dev_name, data, - yaffs2_internal_read_super_mtd, mnt); + yaffs2_internal_read_super_mtd, mnt); } static struct file_system_type yaffs2_fs_type = { @@ -2623,40 +2555,62 @@ static struct file_system_type yaffs2_fs_type = { .kill_sb = kill_block_super, .fs_flags = FS_REQUIRES_DEV, }; -#endif /* CONFIG_YAFFS_YAFFS2 */ +#endif /* CONFIG_YAFFS_YAFFS2 */ static struct proc_dir_entry *my_proc_entry; static struct proc_dir_entry *debug_proc_entry; -static char *yaffs_dump_dev_part0(char *buf, yaffs_dev_t * dev) -{ - buf += sprintf(buf, "start_block........... %d\n", dev->param.start_block); - buf += sprintf(buf, "end_block............. %d\n", dev->param.end_block); - buf += sprintf(buf, "total_bytes_per_chunk. %d\n", dev->param.total_bytes_per_chunk); - buf += sprintf(buf, "use_nand_ecc.......... %d\n", dev->param.use_nand_ecc); - buf += sprintf(buf, "no_tags_ecc........... %d\n", dev->param.no_tags_ecc); - buf += sprintf(buf, "is_yaffs2............. %d\n", dev->param.is_yaffs2); - buf += sprintf(buf, "inband_tags........... %d\n", dev->param.inband_tags); - buf += sprintf(buf, "empty_lost_n_found.... %d\n", dev->param.empty_lost_n_found); - buf += sprintf(buf, "disable_lazy_load..... %d\n", dev->param.disable_lazy_load); - buf += sprintf(buf, "refresh_period........ %d\n", dev->param.refresh_period); +static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev) +{ + buf += + sprintf(buf, "start_block........... %d\n", dev->param.start_block); + buf += + sprintf(buf, "end_block............. %d\n", dev->param.end_block); + buf += + sprintf(buf, "total_bytes_per_chunk. %d\n", + dev->param.total_bytes_per_chunk); + buf += + sprintf(buf, "use_nand_ecc.......... %d\n", + dev->param.use_nand_ecc); + buf += + sprintf(buf, "no_tags_ecc........... %d\n", dev->param.no_tags_ecc); + buf += + sprintf(buf, "is_yaffs2............. %d\n", dev->param.is_yaffs2); + buf += + sprintf(buf, "inband_tags........... %d\n", dev->param.inband_tags); + buf += + sprintf(buf, "empty_lost_n_found.... %d\n", + dev->param.empty_lost_n_found); + buf += + sprintf(buf, "disable_lazy_load..... %d\n", + dev->param.disable_lazy_load); + buf += + sprintf(buf, "refresh_period........ %d\n", + dev->param.refresh_period); buf += sprintf(buf, "n_caches.............. %d\n", dev->param.n_caches); - buf += sprintf(buf, "n_reserved_blocks..... %d\n", dev->param.n_reserved_blocks); - buf += sprintf(buf, "always_check_erased... %d\n", dev->param.always_check_erased); + buf += + sprintf(buf, "n_reserved_blocks..... %d\n", + dev->param.n_reserved_blocks); + buf += + sprintf(buf, "always_check_erased... %d\n", + dev->param.always_check_erased); buf += sprintf(buf, "\n"); return buf; } - -static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev) +static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev) { - buf += sprintf(buf, "data_bytes_per_chunk.. %d\n", dev->data_bytes_per_chunk); + buf += + sprintf(buf, "data_bytes_per_chunk.. %d\n", + dev->data_bytes_per_chunk); buf += sprintf(buf, "chunk_grp_bits........ %d\n", dev->chunk_grp_bits); buf += sprintf(buf, "chunk_grp_size........ %d\n", dev->chunk_grp_size); - buf += sprintf(buf, "n_erased_blocks....... %d\n", dev->n_erased_blocks); - buf += sprintf(buf, "blocks_in_checkpt..... %d\n", dev->blocks_in_checkpt); + buf += + sprintf(buf, "n_erased_blocks....... %d\n", dev->n_erased_blocks); + buf += + sprintf(buf, "blocks_in_checkpt..... %d\n", dev->blocks_in_checkpt); buf += sprintf(buf, "\n"); buf += sprintf(buf, "n_tnodes.............. %d\n", dev->n_tnodes); buf += sprintf(buf, "n_obj................. %d\n", dev->n_obj); @@ -2667,19 +2621,29 @@ static char *yaffs_dump_dev_part1(char *buf, yaffs_dev_t * dev) buf += sprintf(buf, "n_erasures............ %u\n", dev->n_erasures); buf += sprintf(buf, "n_gc_copies........... %u\n", dev->n_gc_copies); buf += sprintf(buf, "all_gcs............... %u\n", dev->all_gcs); - buf += sprintf(buf, "passive_gc_count...... %u\n", dev->passive_gc_count); - buf += sprintf(buf, "oldest_dirty_gc_count. %u\n", dev->oldest_dirty_gc_count); + buf += + sprintf(buf, "passive_gc_count...... %u\n", dev->passive_gc_count); + buf += + sprintf(buf, "oldest_dirty_gc_count. %u\n", + dev->oldest_dirty_gc_count); buf += sprintf(buf, "n_gc_blocks........... %u\n", dev->n_gc_blocks); buf += sprintf(buf, "bg_gcs................ %u\n", dev->bg_gcs); - buf += sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes); - buf += sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks); + buf += + sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes); + buf += + sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks); buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed); buf += sprintf(buf, "n_ecc_unfixed......... %u\n", dev->n_ecc_unfixed); - buf += sprintf(buf, "n_tags_ecc_fixed...... %u\n", dev->n_tags_ecc_fixed); - buf += sprintf(buf, "n_tags_ecc_unfixed.... %u\n", dev->n_tags_ecc_unfixed); + buf += + sprintf(buf, "n_tags_ecc_fixed...... %u\n", dev->n_tags_ecc_fixed); + buf += + sprintf(buf, "n_tags_ecc_unfixed.... %u\n", + dev->n_tags_ecc_unfixed); buf += sprintf(buf, "cache_hits............ %u\n", dev->cache_hits); - buf += sprintf(buf, "n_deleted_files....... %u\n", dev->n_deleted_files); - buf += sprintf(buf, "n_unlinked_files...... %u\n", dev->n_unlinked_files); + buf += + sprintf(buf, "n_deleted_files....... %u\n", dev->n_deleted_files); + buf += + sprintf(buf, "n_unlinked_files...... %u\n", dev->n_unlinked_files); buf += sprintf(buf, "refresh_count......... %u\n", dev->refresh_count); buf += sprintf(buf, "n_bg_deletions........ %u\n", dev->n_bg_deletions); @@ -2690,7 +2654,7 @@ static int yaffs_proc_read(char *page, char **start, off_t offset, int count, int *eof, void *data) { - struct ylist_head *item; + struct list_head *item; char *buf = page; int step = offset; int n = 0; @@ -2705,63 +2669,68 @@ static int yaffs_proc_read(char *page, /* Print header first */ if (step == 0) - buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__"\n"); + buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__ "\n"); else if (step == 1) - buf += sprintf(buf,"\n"); + buf += sprintf(buf, "\n"); else { - step-=2; - - down(&yaffs_context_lock); + step -= 2; + + mutex_lock(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ - ylist_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list); - yaffs_dev_t *dev = dc->dev; + list_for_each(item, &yaffs_context_list) { + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, + context_list); + struct yaffs_dev *dev = dc->dev; if (n < (step & ~1)) { - n+=2; + n += 2; continue; } - if((step & 1)==0){ - buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->param.name); + if ((step & 1) == 0) { + buf += + sprintf(buf, "\nDevice %d \"%s\"\n", n, + dev->param.name); buf = yaffs_dump_dev_part0(buf, dev); } else buf = yaffs_dump_dev_part1(buf, dev); - + break; } - up(&yaffs_context_lock); + mutex_unlock(&yaffs_context_lock); } return buf - page < count ? buf - page : count; } static int yaffs_stats_proc_read(char *page, - char **start, - off_t offset, int count, int *eof, void *data) + char **start, + off_t offset, int count, int *eof, void *data) { - struct ylist_head *item; + struct list_head *item; char *buf = page; int n = 0; - down(&yaffs_context_lock); + mutex_lock(&yaffs_context_lock); /* Locate and print the Nth entry. Order N-squared but N is small. */ - ylist_for_each(item, &yaffs_context_list) { - struct yaffs_linux_context *dc = ylist_entry(item, struct yaffs_linux_context, context_list); - yaffs_dev_t *dev = dc->dev; + list_for_each(item, &yaffs_context_list) { + struct yaffs_linux_context *dc = + list_entry(item, struct yaffs_linux_context, context_list); + struct yaffs_dev *dev = dc->dev; int erased_chunks; - erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - - buf += sprintf(buf,"%d, %d, %d, %u, %u, %u, %u\n", - n, dev->n_free_chunks, erased_chunks, - dev->bg_gcs, dev->oldest_dirty_gc_count, - dev->n_obj, dev->n_tnodes); - } - up(&yaffs_context_lock); + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; + buf += sprintf(buf, "%d, %d, %d, %u, %u, %u, %u\n", + n, dev->n_free_chunks, erased_chunks, + dev->bg_gcs, dev->oldest_dirty_gc_count, + dev->n_obj, dev->n_tnodes); + } + mutex_unlock(&yaffs_context_lock); return buf - page < count ? buf - page : count; } @@ -2776,41 +2745,39 @@ static struct { char *mask_name; unsigned mask_bitfield; } mask_flags[] = { - {"allocate", YAFFS_TRACE_ALLOCATE}, - {"always", YAFFS_TRACE_ALWAYS}, - {"background", YAFFS_TRACE_BACKGROUND}, - {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, - {"buffers", YAFFS_TRACE_BUFFERS}, - {"bug", YAFFS_TRACE_BUG}, - {"checkpt", YAFFS_TRACE_CHECKPOINT}, - {"deletion", YAFFS_TRACE_DELETION}, - {"erase", YAFFS_TRACE_ERASE}, - {"error", YAFFS_TRACE_ERROR}, - {"gc_detail", YAFFS_TRACE_GC_DETAIL}, - {"gc", YAFFS_TRACE_GC}, - {"lock", YAFFS_TRACE_LOCK}, - {"mtd", YAFFS_TRACE_MTD}, - {"nandaccess", YAFFS_TRACE_NANDACCESS}, - {"os", YAFFS_TRACE_OS}, - {"scan_debug", YAFFS_TRACE_SCAN_DEBUG}, - {"scan", YAFFS_TRACE_SCAN}, - {"tracing", YAFFS_TRACE_TRACING}, - {"sync", YAFFS_TRACE_SYNC}, - {"write", YAFFS_TRACE_WRITE}, - - {"verify", YAFFS_TRACE_VERIFY}, - {"verify_nand", YAFFS_TRACE_VERIFY_NAND}, - {"verify_full", YAFFS_TRACE_VERIFY_FULL}, - {"verify_all", YAFFS_TRACE_VERIFY_ALL}, - - {"all", 0xffffffff}, - {"none", 0}, - {NULL, 0}, -}; + { + "allocate", YAFFS_TRACE_ALLOCATE}, { + "always", YAFFS_TRACE_ALWAYS}, { + "background", YAFFS_TRACE_BACKGROUND}, { + "bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, { + "buffers", YAFFS_TRACE_BUFFERS}, { + "bug", YAFFS_TRACE_BUG}, { + "checkpt", YAFFS_TRACE_CHECKPOINT}, { + "deletion", YAFFS_TRACE_DELETION}, { + "erase", YAFFS_TRACE_ERASE}, { + "error", YAFFS_TRACE_ERROR}, { + "gc_detail", YAFFS_TRACE_GC_DETAIL}, { + "gc", YAFFS_TRACE_GC}, { + "lock", YAFFS_TRACE_LOCK}, { + "mtd", YAFFS_TRACE_MTD}, { + "nandaccess", YAFFS_TRACE_NANDACCESS}, { + "os", YAFFS_TRACE_OS}, { + "scan_debug", YAFFS_TRACE_SCAN_DEBUG}, { + "scan", YAFFS_TRACE_SCAN}, { + "tracing", YAFFS_TRACE_TRACING}, { + "sync", YAFFS_TRACE_SYNC}, { + "write", YAFFS_TRACE_WRITE}, { + "verify", YAFFS_TRACE_VERIFY}, { + "verify_nand", YAFFS_TRACE_VERIFY_NAND}, { + "verify_full", YAFFS_TRACE_VERIFY_FULL}, { + "verify_all", YAFFS_TRACE_VERIFY_ALL}, { + "all", 0xffffffff}, { + "none", 0}, { +NULL, 0},}; #define MAX_MASK_NAME_LENGTH 40 static int yaffs_proc_write_trace_options(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { unsigned rg = 0, mask_bitfield; char *end; @@ -2852,15 +2819,17 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, done = 0; } else { for (x = buf + pos, i = 0; - (*x == '_' || (*x >= 'a' && *x <= 'z')) && - i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) + (*x == '_' || (*x >= 'a' && *x <= 'z')) && + i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) substring[i] = *x; substring[i] = '\0'; for (i = 0; mask_flags[i].mask_name != NULL; i++) { - if (strcmp(substring, mask_flags[i].mask_name) == 0) { + if (strcmp(substring, mask_flags[i].mask_name) + == 0) { mask_name = mask_flags[i].mask_name; - mask_bitfield = mask_flags[i].mask_bitfield; + mask_bitfield = + mask_flags[i].mask_bitfield; done = 0; break; } @@ -2895,18 +2864,18 @@ static int yaffs_proc_write_trace_options(struct file *file, const char *buf, char flag; flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-'; - printk(KERN_DEBUG "%c%s\n", flag, mask_flags[i].mask_name); + printk(KERN_DEBUG "%c%s\n", flag, + mask_flags[i].mask_name); } } return count; } - static int yaffs_proc_write(struct file *file, const char *buf, - unsigned long count, void *data) + unsigned long count, void *data) { - return yaffs_proc_write_trace_options(file, buf, count, data); + return yaffs_proc_write_trace_options(file, buf, count, data); } /* Stuff to handle installation of file systems */ @@ -2931,18 +2900,15 @@ static int __init init_yaffs_fs(void) #ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED T(YAFFS_TRACE_ALWAYS, - (TSTR(" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); + (TSTR + (" \n\n\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n\n"))); #endif - - - - init_MUTEX(&yaffs_context_lock); + mutex_init(&yaffs_context_lock); /* Install the proc_fs entries */ my_proc_entry = create_proc_entry("yaffs", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (my_proc_entry) { my_proc_entry->write_proc = yaffs_proc_write; @@ -2952,8 +2918,7 @@ static int __init init_yaffs_fs(void) return -ENOMEM; debug_proc_entry = create_proc_entry("yaffs_stats", - S_IRUGO | S_IFREG, - YPROC_ROOT); + S_IRUGO | S_IFREG, YPROC_ROOT); if (debug_proc_entry) { debug_proc_entry->write_proc = NULL; @@ -2995,7 +2960,7 @@ static void __exit exit_yaffs_fs(void) struct file_system_to_install *fsinst; T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); + (TSTR("yaffs built " __DATE__ " " __TIME__ " removing. \n"))); remove_proc_entry("yaffs", YPROC_ROOT); remove_proc_entry("yaffs_stats", YPROC_ROOT); @@ -3012,8 +2977,8 @@ static void __exit exit_yaffs_fs(void) } module_init(init_yaffs_fs) -module_exit(exit_yaffs_fs) + module_exit(exit_yaffs_fs) -MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); + MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010"); MODULE_LICENSE("GPL"); diff --git a/yaffs_yaffs1.c b/yaffs_yaffs1.c index 21933dc..4ab0f22 100644 --- a/yaffs_yaffs1.c +++ b/yaffs_yaffs1.c @@ -17,33 +17,30 @@ #include "yaffs_bitmap.h" #include "yaffs_getblockinfo.h" #include "yaffs_nand.h" +#include "yaffs_attribs.h" - -int yaffs1_scan(yaffs_dev_t *dev) +int yaffs1_scan(struct yaffs_dev *dev) { - yaffs_ext_tags tags; + struct yaffs_ext_tags tags; int blk; int result; int chunk; int c; int deleted; - yaffs_block_state_t state; - yaffs_obj_t *hard_list = NULL; - yaffs_block_info_t *bi; - __u32 seq_number; - yaffs_obj_header *oh; - yaffs_obj_t *in; - yaffs_obj_t *parent; + enum yaffs_block_state state; + struct yaffs_obj *hard_list = NULL; + struct yaffs_block_info *bi; + u32 seq_number; + struct yaffs_obj_hdr *oh; + struct yaffs_obj *in; + struct yaffs_obj *parent; int alloc_failed = 0; - struct yaffs_shadow_fixer_s *shadow_fixers = NULL; - - - __u8 *chunk_data; - + struct yaffs_shadow_fixer *shadow_fixers = NULL; + u8 *chunk_data; T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan starts intstartblk %d intendblk %d..." TENDSTR), @@ -55,7 +52,8 @@ int yaffs1_scan(yaffs_dev_t *dev) /* Scan all the blocks to determine their state */ bi = dev->block_info; - for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; + blk++) { yaffs_clear_chunk_bits(dev, blk); bi->pages_in_use = 0; bi->soft_del_pages = 0; @@ -85,9 +83,8 @@ int yaffs1_scan(yaffs_dev_t *dev) } /* For each block.... */ - for (blk= dev->internal_start_block; - !alloc_failed && blk <= dev->internal_end_block; - blk++) { + for (blk = dev->internal_start_block; + !alloc_failed && blk <= dev->internal_end_block; blk++) { YYIELD(); @@ -96,18 +93,19 @@ int yaffs1_scan(yaffs_dev_t *dev) deleted = 0; - /* For each chunk in each block that needs scanning....*/ + /* For each chunk in each block that needs scanning.... */ for (c = 0; !alloc_failed && c < dev->param.chunks_per_block && state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { /* Read the tags and decide what to do */ chunk = blk * dev->param.chunks_per_block + c; result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, - &tags); + &tags); /* Let's have a good look at this chunk... */ - if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED || tags.is_deleted) { + if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED + || tags.is_deleted) { /* YAFFS1 only... * A deleted chunk */ @@ -138,7 +136,8 @@ int yaffs1_scan(yaffs_dev_t *dev) } - dev->n_free_chunks += (dev->param.chunks_per_block - c); + dev->n_free_chunks += + (dev->param.chunks_per_block - c); } else if (tags.chunk_id > 0) { /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; @@ -147,9 +146,8 @@ int yaffs1_scan(yaffs_dev_t *dev) bi->pages_in_use++; in = yaffs_find_or_create_by_number(dev, - tags. - obj_id, - YAFFS_OBJECT_TYPE_FILE); + tags.obj_id, + YAFFS_OBJECT_TYPE_FILE); /* PutChunkIntoFile checks for a clash (two data chunks with * the same chunk_id). */ @@ -158,24 +156,27 @@ int yaffs1_scan(yaffs_dev_t *dev) alloc_failed = 1; if (in) { - if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, 1)) + if (!yaffs_put_chunk_in_file + (in, tags.chunk_id, chunk, 1)) alloc_failed = 1; } endpos = - (tags.chunk_id - 1) * dev->data_bytes_per_chunk + + (tags.chunk_id - + 1) * dev->data_bytes_per_chunk + tags.n_bytes; - if (in && - in->variant_type == YAFFS_OBJECT_TYPE_FILE + if (in + && in->variant_type == + YAFFS_OBJECT_TYPE_FILE && in->variant.file_variant.scanned_size < endpos) { - in->variant.file_variant. - scanned_size = endpos; + in->variant.file_variant.scanned_size = + endpos; if (!dev->param.use_header_file_size) { - in->variant.file_variant. - file_size = - in->variant.file_variant. - scanned_size; + in->variant. + file_variant.file_size = + in->variant. + file_variant.scanned_size; } } @@ -188,13 +189,12 @@ int yaffs1_scan(yaffs_dev_t *dev) bi->pages_in_use++; result = yaffs_rd_chunk_tags_nand(dev, chunk, - chunk_data, - NULL); + chunk_data, + NULL); - oh = (yaffs_obj_header *) chunk_data; + oh = (struct yaffs_obj_hdr *)chunk_data; - in = yaffs_find_by_number(dev, - tags.obj_id); + in = yaffs_find_by_number(dev, tags.obj_id); if (in && in->variant_type != oh->type) { /* This should not happen, but somehow * Wev'e ended up with an obj_id that has been reused but not yet @@ -207,26 +207,30 @@ int yaffs1_scan(yaffs_dev_t *dev) } in = yaffs_find_or_create_by_number(dev, - tags. - obj_id, - oh->type); + tags.obj_id, + oh->type); if (!in) alloc_failed = 1; if (in && oh->shadows_obj > 0) { - struct yaffs_shadow_fixer_s *fixer; - fixer = YMALLOC(sizeof(struct yaffs_shadow_fixer_s)); + struct yaffs_shadow_fixer *fixer; + fixer = + YMALLOC(sizeof + (struct + yaffs_shadow_fixer)); if (fixer) { fixer->next = shadow_fixers; shadow_fixers = fixer; fixer->obj_id = tags.obj_id; - fixer->shadowed_id = oh->shadows_obj; + fixer->shadowed_id = + oh->shadows_obj; T(YAFFS_TRACE_SCAN, (TSTR - (" Shadow fixer: %d shadows %d" TENDSTR), - fixer->obj_id, fixer->shadowed_id)); + (" Shadow fixer: %d shadows %d" + TENDSTR), fixer->obj_id, + fixer->shadowed_id)); } @@ -236,44 +240,33 @@ int yaffs1_scan(yaffs_dev_t *dev) /* We have already filled this one. We have a duplicate and need to resolve it. */ unsigned existing_serial = in->serial; - unsigned new_serial = tags.serial_number; + unsigned new_serial = + tags.serial_number; - if (((existing_serial + 1) & 3) == new_serial) { + if (((existing_serial + 1) & 3) == + new_serial) { /* Use new one - destroy the exisiting one */ yaffs_chunk_del(dev, - in->hdr_chunk, - 1, __LINE__); + in->hdr_chunk, + 1, __LINE__); in->valid = 0; } else { /* Use existing - destroy this one. */ yaffs_chunk_del(dev, chunk, 1, - __LINE__); + __LINE__); } } if (in && !in->valid && (tags.obj_id == YAFFS_OBJECTID_ROOT || - tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND)) { + tags.obj_id == + YAFFS_OBJECTID_LOSTNFOUND)) { /* We only load some info, don't fiddle with directory structure */ in->valid = 1; in->variant_type = oh->type; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -#endif + yaffs_load_attribs(in, oh); in->hdr_chunk = chunk; in->serial = tags.serial_number; @@ -284,21 +277,7 @@ int yaffs1_scan(yaffs_dev_t *dev) in->variant_type = oh->type; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -#endif + yaffs_load_attribs(in, oh); in->hdr_chunk = chunk; in->serial = tags.serial_number; @@ -319,12 +298,13 @@ int yaffs1_scan(yaffs_dev_t *dev) YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ parent->variant_type = - YAFFS_OBJECT_TYPE_DIRECTORY; - YINIT_LIST_HEAD(&parent->variant. - dir_variant. - children); - } else if (!parent || parent->variant_type != - YAFFS_OBJECT_TYPE_DIRECTORY) { + YAFFS_OBJECT_TYPE_DIRECTORY; + INIT_LIST_HEAD(&parent-> + variant.dir_variant.children); + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) + { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory */ @@ -339,7 +319,8 @@ int yaffs1_scan(yaffs_dev_t *dev) yaffs_add_obj_to_dir(parent, in); if (0 && (parent == dev->del_dir || - parent == dev->unlinked_dir)) { + parent == + dev->unlinked_dir)) { in->deleted = 1; /* If it is unlinked at start up then it wants deleting */ dev->n_deleted_files++; } @@ -355,20 +336,21 @@ int yaffs1_scan(yaffs_dev_t *dev) /* Todo got a problem */ break; case YAFFS_OBJECT_TYPE_FILE: - if (dev->param.use_header_file_size) + if (dev->param. + use_header_file_size) - in->variant.file_variant. - file_size = - oh->file_size; + in->variant. + file_variant.file_size + = oh->file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardlink_variant. - equiv_id = - oh->equiv_id; + in->variant. + hardlink_variant.equiv_id = + oh->equiv_id; in->hard_links.next = - (struct ylist_head *) - hard_list; + (struct list_head *) + hard_list; hard_list = in; break; case YAFFS_OBJECT_TYPE_DIRECTORY: @@ -378,9 +360,11 @@ int yaffs1_scan(yaffs_dev_t *dev) /* Do nothing */ break; case YAFFS_OBJECT_TYPE_SYMLINK: - in->variant.symlink_variant.alias = + in->variant.symlink_variant. + alias = yaffs_clone_str(oh->alias); - if (!in->variant.symlink_variant.alias) + if (!in->variant. + symlink_variant.alias) alloc_failed = 1; break; } @@ -390,12 +374,12 @@ int yaffs1_scan(yaffs_dev_t *dev) } if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - /* If we got this far while scanning, then the block is fully allocated.*/ + /* If we got this far while scanning, then the block is fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; } if (state == YAFFS_BLOCK_STATE_ALLOCATING) { - /* If the block was partially allocated then treat it as fully allocated.*/ + /* If the block was partially allocated then treat it as fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; dev->alloc_block = -1; } @@ -411,7 +395,6 @@ int yaffs1_scan(yaffs_dev_t *dev) } - /* Ok, we've done all the scanning. * Fix up the hard link chains. * We should now have scanned all the objects, now it's time to add these @@ -422,8 +405,8 @@ int yaffs1_scan(yaffs_dev_t *dev) /* Fix up any shadowed objects */ { - struct yaffs_shadow_fixer_s *fixer; - yaffs_obj_t *obj; + struct yaffs_shadow_fixer *fixer; + struct yaffs_obj *obj; while (shadow_fixers) { fixer = shadow_fixers; @@ -451,7 +434,5 @@ int yaffs1_scan(yaffs_dev_t *dev) T(YAFFS_TRACE_SCAN, (TSTR("yaffs1_scan ends" TENDSTR))); - return YAFFS_OK; } - diff --git a/yaffs_yaffs1.h b/yaffs_yaffs1.h index 1f60b0c..db23e04 100644 --- a/yaffs_yaffs1.h +++ b/yaffs_yaffs1.h @@ -17,6 +17,6 @@ #define __YAFFS_YAFFS1_H__ #include "yaffs_guts.h" -int yaffs1_scan(yaffs_dev_t *dev); +int yaffs1_scan(struct yaffs_dev *dev); #endif diff --git a/yaffs_yaffs2.c b/yaffs_yaffs2.c index 76623ad..97dac45 100644 --- a/yaffs_yaffs2.c +++ b/yaffs_yaffs2.c @@ -11,16 +11,15 @@ * published by the Free Software Foundation. */ - #include "yaffs_guts.h" #include "yaffs_trace.h" #include "yaffs_yaffs2.h" #include "yaffs_checkptrw.h" #include "yaffs_bitmap.h" -#include "yaffs_qsort.h" #include "yaffs_nand.h" #include "yaffs_getblockinfo.h" #include "yaffs_verify.h" +#include "yaffs_attribs.h" /* * Checkpoints are really no benefit on very small partitions. @@ -32,23 +31,22 @@ #define YAFFS_SMALL_HOLE_THRESHOLD 4 - /* * Oldest Dirty Sequence Number handling. */ - + /* yaffs_calc_oldest_dirty_seq() * yaffs2_find_oldest_dirty_seq() * Calculate the oldest dirty sequence number if we don't know it. */ -void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev) +void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev) { int i; unsigned seq; unsigned block_no = 0; - yaffs_block_info_t *b; + struct yaffs_block_info *b; - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; /* Find the oldest dirty sequence number. */ @@ -56,28 +54,27 @@ void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev) b = dev->block_info; for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { if (b->block_state == YAFFS_BLOCK_STATE_FULL && - (b->pages_in_use - b->soft_del_pages) < dev->param.chunks_per_block && - b->seq_number < seq) { + (b->pages_in_use - b->soft_del_pages) < + dev->param.chunks_per_block && b->seq_number < seq) { seq = b->seq_number; block_no = i; } b++; } - if(block_no){ + if (block_no) { dev->oldest_dirty_seq = seq; dev->oldest_dirty_block = block_no; } } - -void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev) +void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev) { - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; - if(!dev->oldest_dirty_seq) + if (!dev->oldest_dirty_seq) yaffs_calc_oldest_dirty_seq(dev); } @@ -87,13 +84,14 @@ void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev) * becomes invalid). If the value matches the oldest then we clear * dev->oldest_dirty_seq to force its recomputation. */ -void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi) +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, + struct yaffs_block_info *bi) { - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; - if(!bi || bi->seq_number == dev->oldest_dirty_seq){ + if (!bi || bi->seq_number == dev->oldest_dirty_seq) { dev->oldest_dirty_seq = 0; dev->oldest_dirty_block = 0; } @@ -104,21 +102,21 @@ void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi) * Update the oldest dirty sequence number whenever we dirty a block. * Only do this if the oldest_dirty_seq is actually being tracked. */ -void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi) +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *bi) { - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return; - if(dev->oldest_dirty_seq){ - if(dev->oldest_dirty_seq > bi->seq_number){ + if (dev->oldest_dirty_seq) { + if (dev->oldest_dirty_seq > bi->seq_number) { dev->oldest_dirty_seq = bi->seq_number; dev->oldest_dirty_block = block_no; } } } -int yaffs_block_ok_for_gc(yaffs_dev_t *dev, - yaffs_block_info_t *bi) +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi) { if (!dev->param.is_yaffs2) @@ -140,32 +138,32 @@ int yaffs_block_ok_for_gc(yaffs_dev_t *dev, * periodically finds the oldest full block by sequence number for refreshing. * Only for yaffs2. */ -__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev) +u32 yaffs2_find_refresh_block(struct yaffs_dev * dev) { - __u32 b ; + u32 b; - __u32 oldest = 0; - __u32 oldest_seq = 0; + u32 oldest = 0; + u32 oldest_seq = 0; - yaffs_block_info_t *bi; + struct yaffs_block_info *bi; - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return oldest; /* * If refresh period < 10 then refreshing is disabled. */ - if(dev->param.refresh_period < 10) - return oldest; + if (dev->param.refresh_period < 10) + return oldest; - /* - * Fix broken values. - */ - if(dev->refresh_skip > dev->param.refresh_period) - dev->refresh_skip = dev->param.refresh_period; + /* + * Fix broken values. + */ + if (dev->refresh_skip > dev->param.refresh_period) + dev->refresh_skip = dev->param.refresh_period; - if(dev->refresh_skip > 0) - return oldest; + if (dev->refresh_skip > 0) + return oldest; /* * Refresh skip is now zero. @@ -175,84 +173,87 @@ __u32 yaffs2_find_refresh_block(yaffs_dev_t *dev) dev->refresh_skip = dev->param.refresh_period; dev->refresh_count++; bi = dev->block_info; - for (b = dev->internal_start_block; b <=dev->internal_end_block; b++){ + for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { - if (bi->block_state == YAFFS_BLOCK_STATE_FULL){ + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) { - if(oldest < 1 || - bi->seq_number < oldest_seq){ - oldest = b; - oldest_seq = bi->seq_number; - } + if (oldest < 1 || bi->seq_number < oldest_seq) { + oldest = b; + oldest_seq = bi->seq_number; + } } bi++; } if (oldest > 0) { T(YAFFS_TRACE_GC, - (TSTR("GC refresh count %d selected block %d with seq_number %d" TENDSTR), - dev->refresh_count, oldest, oldest_seq)); + (TSTR + ("GC refresh count %d selected block %d with seq_number %d" + TENDSTR), dev->refresh_count, oldest, oldest_seq)); } return oldest; } -int yaffs2_checkpt_required(yaffs_dev_t *dev) +int yaffs2_checkpt_required(struct yaffs_dev *dev) { int nblocks; - - if(!dev->param.is_yaffs2) + + if (!dev->param.is_yaffs2) return 0; - - nblocks = dev->internal_end_block - dev->internal_start_block + 1 ; - return !dev->param.skip_checkpt_wr && - !dev->read_only && - (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); + nblocks = dev->internal_end_block - dev->internal_start_block + 1; + + return !dev->param.skip_checkpt_wr && + !dev->read_only && (nblocks >= YAFFS_CHECKPOINT_MIN_BLOCKS); } -int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev) +int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev) { int retval; - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return 0; - if (!dev->checkpoint_blocks_required && - yaffs2_checkpt_required(dev)){ + if (!dev->checkpoint_blocks_required && yaffs2_checkpt_required(dev)) { /* Not a valid value so recalculate */ int n_bytes = 0; int n_blocks; - int dev_blocks = (dev->param.end_block - dev->param.start_block + 1); + int dev_blocks = + (dev->param.end_block - dev->param.start_block + 1); - n_bytes += sizeof(yaffs_checkpt_validty_t); - n_bytes += sizeof(yaffs_checkpt_dev_t); - n_bytes += dev_blocks * sizeof(yaffs_block_info_t); + n_bytes += sizeof(struct yaffs_checkpt_validity); + n_bytes += sizeof(struct yaffs_checkpt_dev); + n_bytes += dev_blocks * sizeof(struct yaffs_block_info); n_bytes += dev_blocks * dev->chunk_bit_stride; - n_bytes += (sizeof(yaffs_checkpt_obj_t) + sizeof(__u32)) * (dev->n_obj); - n_bytes += (dev->tnode_size + sizeof(__u32)) * (dev->n_tnodes); - n_bytes += sizeof(yaffs_checkpt_validty_t); - n_bytes += sizeof(__u32); /* checksum*/ + n_bytes += + (sizeof(struct yaffs_checkpt_obj) + + sizeof(u32)) * (dev->n_obj); + n_bytes += (dev->tnode_size + sizeof(u32)) * (dev->n_tnodes); + n_bytes += sizeof(struct yaffs_checkpt_validity); + n_bytes += sizeof(u32); /* checksum */ /* Round up and add 2 blocks to allow for some bad blocks, so add 3 */ - n_blocks = (n_bytes/(dev->data_bytes_per_chunk * dev->param.chunks_per_block)) + 3; + n_blocks = + (n_bytes / + (dev->data_bytes_per_chunk * + dev->param.chunks_per_block)) + 3; dev->checkpoint_blocks_required = n_blocks; } retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt; - if(retval < 0) + if (retval < 0) retval = 0; return retval; } /*--------------------- Checkpointing --------------------*/ - -static int yaffs2_wr_checkpt_validity_marker(yaffs_dev_t *dev, int head) +static int yaffs2_wr_checkpt_validity_marker(struct yaffs_dev *dev, int head) { - yaffs_checkpt_validty_t cp; + struct yaffs_checkpt_validity cp; memset(&cp, 0, sizeof(cp)); @@ -261,27 +262,26 @@ static int yaffs2_wr_checkpt_validity_marker(yaffs_dev_t *dev, int head) cp.version = YAFFS_CHECKPOINT_VERSION; cp.head = (head) ? 1 : 0; - return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? - 1 : 0; + return (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)) ? 1 : 0; } -static int yaffs2_rd_checkpt_validty_marker(yaffs_dev_t *dev, int head) +static int yaffs2_rd_checkpt_validity_marker(struct yaffs_dev *dev, int head) { - yaffs_checkpt_validty_t cp; + struct yaffs_checkpt_validity cp; int ok; ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); if (ok) ok = (cp.struct_type == sizeof(cp)) && - (cp.magic == YAFFS_MAGIC) && - (cp.version == YAFFS_CHECKPOINT_VERSION) && - (cp.head == ((head) ? 1 : 0)); + (cp.magic == YAFFS_MAGIC) && + (cp.version == YAFFS_CHECKPOINT_VERSION) && + (cp.head == ((head) ? 1 : 0)); return ok ? 1 : 0; } -static void yaffs2_dev_to_checkpt_dev(yaffs_checkpt_dev_t *cp, - yaffs_dev_t *dev) +static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp, + struct yaffs_dev *dev) { cp->n_erased_blocks = dev->n_erased_blocks; cp->alloc_block = dev->alloc_block; @@ -295,8 +295,8 @@ static void yaffs2_dev_to_checkpt_dev(yaffs_checkpt_dev_t *cp, } -static void yaffs_checkpt_dev_to_dev(yaffs_dev_t *dev, - yaffs_checkpt_dev_t *cp) +static void yaffs_checkpt_dev_to_dev(struct yaffs_dev *dev, + struct yaffs_checkpt_dev *cp) { dev->n_erased_blocks = cp->n_erased_blocks; dev->alloc_block = cp->alloc_block; @@ -309,16 +309,16 @@ static void yaffs_checkpt_dev_to_dev(yaffs_dev_t *dev, dev->seq_number = cp->seq_number; } - -static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev) +static int yaffs2_wr_checkpt_dev(struct yaffs_dev *dev) { - yaffs_checkpt_dev_t cp; - __u32 n_bytes; - __u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1); + struct yaffs_checkpt_dev cp; + u32 n_bytes; + u32 n_blocks = + (dev->internal_end_block - dev->internal_start_block + 1); int ok; - /* Write device runtime values*/ + /* Write device runtime values */ yaffs2_dev_to_checkpt_dev(&cp, dev); cp.struct_type = sizeof(cp); @@ -326,24 +326,27 @@ static int yaffs2_wr_checkpt_dev(yaffs_dev_t *dev) /* Write block info */ if (ok) { - n_bytes = n_blocks * sizeof(yaffs_block_info_t); - ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes); + n_bytes = n_blocks * sizeof(struct yaffs_block_info); + ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == + n_bytes); } /* Write chunk bits */ if (ok) { n_bytes = n_blocks * dev->chunk_bit_stride; - ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == n_bytes); + ok = (yaffs2_checkpt_wr(dev, dev->chunk_bits, n_bytes) == + n_bytes); } - return ok ? 1 : 0; + return ok ? 1 : 0; } -static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev) +static int yaffs2_rd_checkpt_dev(struct yaffs_dev *dev) { - yaffs_checkpt_dev_t cp; - __u32 n_bytes; - __u32 n_blocks = (dev->internal_end_block - dev->internal_start_block + 1); + struct yaffs_checkpt_dev cp; + u32 n_bytes; + u32 n_blocks = + (dev->internal_end_block - dev->internal_start_block + 1); int ok; @@ -354,10 +357,9 @@ static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev) if (cp.struct_type != sizeof(cp)) return 0; - yaffs_checkpt_dev_to_dev(dev, &cp); - n_bytes = n_blocks * sizeof(yaffs_block_info_t); + n_bytes = n_blocks * sizeof(struct yaffs_block_info); ok = (yaffs2_checkpt_rd(dev, dev->block_info, n_bytes) == n_bytes); @@ -370,8 +372,8 @@ static int yaffs2_rd_checkpt_dev(yaffs_dev_t *dev) return ok ? 1 : 0; } -static void yaffs2_obj_checkpt_obj(yaffs_checkpt_obj_t *cp, - yaffs_obj_t *obj) +static void yaffs2_obj_checkpt_obj(struct yaffs_checkpt_obj *cp, + struct yaffs_obj *obj) { cp->obj_id = obj->obj_id; @@ -393,36 +395,40 @@ static void yaffs2_obj_checkpt_obj(yaffs_checkpt_obj_t *cp, cp->size_or_equiv_obj = obj->variant.hardlink_variant.equiv_id; } -static int taffs2_checkpt_obj_to_obj(yaffs_obj_t *obj, yaffs_checkpt_obj_t *cp) +static int taffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, + struct yaffs_checkpt_obj *cp) { - yaffs_obj_t *parent; + struct yaffs_obj *parent; if (obj->variant_type != cp->variant_type) { T(YAFFS_TRACE_ERROR, (TSTR("Checkpoint read object %d type %d " - TCONT("chunk %d does not match existing object type %d") - TENDSTR), cp->obj_id, cp->variant_type, cp->hdr_chunk, - obj->variant_type)); + TCONT + ("chunk %d does not match existing object type %d") + TENDSTR), cp->obj_id, + cp->variant_type, cp->hdr_chunk, + obj->variant_type)); return 0; } obj->obj_id = cp->obj_id; if (cp->parent_id) - parent = yaffs_find_or_create_by_number( - obj->my_dev, - cp->parent_id, - YAFFS_OBJECT_TYPE_DIRECTORY); + parent = yaffs_find_or_create_by_number(obj->my_dev, + cp->parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); else parent = NULL; if (parent) { if (parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, (TSTR("Checkpoint read object %d parent %d type %d" - TCONT(" chunk %d Parent type, %d, not directory") - TENDSTR), - cp->obj_id, cp->parent_id, cp->variant_type, - cp->hdr_chunk, parent->variant_type)); + T(YAFFS_TRACE_ALWAYS, + (TSTR + ("Checkpoint read object %d parent %d type %d" + TCONT(" chunk %d Parent type, %d, not directory") + TENDSTR), cp->obj_id, cp->parent_id, + cp->variant_type, cp->hdr_chunk, + parent->variant_type)); return 0; } yaffs_add_obj_to_dir(parent, obj); @@ -449,13 +455,12 @@ static int taffs2_checkpt_obj_to_obj(yaffs_obj_t *obj, yaffs_checkpt_obj_t *cp) return 1; } - - -static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, - __u32 level, int chunk_offset) +static int yaffs2_checkpt_tnode_worker(struct yaffs_obj *in, + struct yaffs_tnode *tn, u32 level, + int chunk_offset) { int i; - yaffs_dev_t *dev = in->my_dev; + struct yaffs_dev *dev = in->my_dev; int ok = 1; if (tn) { @@ -464,17 +469,27 @@ static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { if (tn->internal[i]) { ok = yaffs2_checkpt_tnode_worker(in, - tn->internal[i], - level - 1, - (chunk_offset< + internal + [i], + level - + 1, + (chunk_offset + << + YAFFS_TNODES_INTERNAL_BITS) + + i); } } } else if (level == 0) { - __u32 base_offset = chunk_offset << YAFFS_TNODES_LEVEL0_BITS; - ok = (yaffs2_checkpt_wr(dev, &base_offset, sizeof(base_offset)) == - sizeof(base_offset)); + u32 base_offset = + chunk_offset << YAFFS_TNODES_LEVEL0_BITS; + ok = (yaffs2_checkpt_wr + (dev, &base_offset, + sizeof(base_offset)) == sizeof(base_offset)); if (ok) - ok = (yaffs2_checkpt_wr(dev, tn, dev->tnode_size) == dev->tnode_size); + ok = (yaffs2_checkpt_wr + (dev, tn, + dev->tnode_size) == dev->tnode_size); } } @@ -482,101 +497,110 @@ static int yaffs2_checkpt_tnode_worker(yaffs_obj_t *in, yaffs_tnode_t *tn, } -static int yaffs2_wr_checkpt_tnodes(yaffs_obj_t *obj) +static int yaffs2_wr_checkpt_tnodes(struct yaffs_obj *obj) { - __u32 end_marker = ~0; + u32 end_marker = ~0; int ok = 1; if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ok = yaffs2_checkpt_tnode_worker(obj, - obj->variant.file_variant.top, - obj->variant.file_variant.top_level, - 0); + obj->variant.file_variant.top, + obj->variant.file_variant. + top_level, 0); if (ok) - ok = (yaffs2_checkpt_wr(obj->my_dev, &end_marker, sizeof(end_marker)) == - sizeof(end_marker)); + ok = (yaffs2_checkpt_wr + (obj->my_dev, &end_marker, + sizeof(end_marker)) == sizeof(end_marker)); } return ok ? 1 : 0; } -static int yaffs2_rd_checkpt_tnodes(yaffs_obj_t *obj) +static int yaffs2_rd_checkpt_tnodes(struct yaffs_obj *obj) { - __u32 base_chunk; + u32 base_chunk; int ok = 1; - yaffs_dev_t *dev = obj->my_dev; - yaffs_file_s *file_stuct_ptr = &obj->variant.file_variant; - yaffs_tnode_t *tn; + struct yaffs_dev *dev = obj->my_dev; + struct yaffs_file_var *file_stuct_ptr = &obj->variant.file_variant; + struct yaffs_tnode *tn; int nread = 0; - ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk)); + ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == + sizeof(base_chunk)); while (ok && (~base_chunk)) { nread++; /* Read level 0 tnode */ - tn = yaffs_get_tnode(dev); - if (tn){ - ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == dev->tnode_size); + if (tn) { + ok = (yaffs2_checkpt_rd(dev, tn, dev->tnode_size) == + dev->tnode_size); } else ok = 0; if (tn && ok) ok = yaffs_add_find_tnode_0(dev, - file_stuct_ptr, - base_chunk, - tn) ? 1 : 0; + file_stuct_ptr, + base_chunk, tn) ? 1 : 0; if (ok) - ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == sizeof(base_chunk)); + ok = (yaffs2_checkpt_rd + (dev, &base_chunk, + sizeof(base_chunk)) == sizeof(base_chunk)); } - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), - nread, base_chunk, ok)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), + nread, base_chunk, ok)); return ok ? 1 : 0; } - -static int yaffs2_wr_checkpt_objs(yaffs_dev_t *dev) +static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev) { - yaffs_obj_t *obj; - yaffs_checkpt_obj_t cp; + struct yaffs_obj *obj; + struct yaffs_checkpt_obj cp; int i; int ok = 1; - struct ylist_head *lh; - + struct list_head *lh; /* Iterate through the objects in each hash entry, * dumping them to the checkpointing stream. */ - for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { - ylist_for_each(lh, &dev->obj_bucket[i].list) { + for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each(lh, &dev->obj_bucket[i].list) { if (lh) { - obj = ylist_entry(lh, yaffs_obj_t, hash_link); + obj = + list_entry(lh, struct yaffs_obj, hash_link); if (!obj->defered_free) { yaffs2_obj_checkpt_obj(&cp, obj); cp.struct_type = sizeof(cp); - T(YAFFS_TRACE_CHECKPOINT, ( - TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" TENDSTR), - cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk, obj)); - - ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); - - if (ok && obj->variant_type == YAFFS_OBJECT_TYPE_FILE) - ok = yaffs2_wr_checkpt_tnodes(obj); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("Checkpoint write object %d parent %d type %d chunk %d obj addr %p" + TENDSTR), cp.obj_id, cp.parent_id, + cp.variant_type, cp.hdr_chunk, obj)); + + ok = (yaffs2_checkpt_wr + (dev, &cp, + sizeof(cp)) == sizeof(cp)); + + if (ok + && obj->variant_type == + YAFFS_OBJECT_TYPE_FILE) + ok = yaffs2_wr_checkpt_tnodes + (obj); } } } } /* Dump end of list */ - memset(&cp, 0xFF, sizeof(yaffs_checkpt_obj_t)); + memset(&cp, 0xFF, sizeof(struct yaffs_checkpt_obj)); cp.struct_type = sizeof(cp); if (ok) @@ -585,38 +609,45 @@ static int yaffs2_wr_checkpt_objs(yaffs_dev_t *dev) return ok ? 1 : 0; } -static int yaffs2_rd_checkpt_objs(yaffs_dev_t *dev) +static int yaffs2_rd_checkpt_objs(struct yaffs_dev *dev) { - yaffs_obj_t *obj; - yaffs_checkpt_obj_t cp; + struct yaffs_obj *obj; + struct yaffs_checkpt_obj cp; int ok = 1; int done = 0; - yaffs_obj_t *hard_list = NULL; + struct yaffs_obj *hard_list = NULL; while (ok && !done) { ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); if (cp.struct_type != sizeof(cp)) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("struct size %d instead of %d ok %d"TENDSTR), - cp.struct_type, (int)sizeof(cp), ok)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("struct size %d instead of %d ok %d" TENDSTR), + cp.struct_type, (int)sizeof(cp), ok)); ok = 0; } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR), - cp.obj_id, cp.parent_id, cp.variant_type, cp.hdr_chunk)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR + ("Checkpoint read object %d parent %d type %d chunk %d " + TENDSTR), cp.obj_id, cp.parent_id, cp.variant_type, + cp.hdr_chunk)); if (ok && cp.obj_id == ~0) done = 1; else if (ok) { - obj = yaffs_find_or_create_by_number(dev, cp.obj_id, cp.variant_type); + obj = + yaffs_find_or_create_by_number(dev, cp.obj_id, + cp.variant_type); if (obj) { ok = taffs2_checkpt_obj_to_obj(obj, &cp); if (!ok) break; if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) { ok = yaffs2_rd_checkpt_tnodes(obj); - } else if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { + } else if (obj->variant_type == + YAFFS_OBJECT_TYPE_HARDLINK) { obj->hard_links.next = - (struct ylist_head *) hard_list; + (struct list_head *)hard_list; hard_list = obj; } } else @@ -630,14 +661,15 @@ static int yaffs2_rd_checkpt_objs(yaffs_dev_t *dev) return ok ? 1 : 0; } -static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev) +static int yaffs2_wr_checkpt_sum(struct yaffs_dev *dev) { - __u32 checkpt_sum; + u32 checkpt_sum; int ok; yaffs2_get_checkpt_sum(dev, &checkpt_sum); - ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == sizeof(checkpt_sum)); + ok = (yaffs2_checkpt_wr(dev, &checkpt_sum, sizeof(checkpt_sum)) == + sizeof(checkpt_sum)); if (!ok) return 0; @@ -645,15 +677,16 @@ static int yaffs2_wr_checkpt_sum(yaffs_dev_t *dev) return 1; } -static int yaffs2_rd_checkpt_sum(yaffs_dev_t *dev) +static int yaffs2_rd_checkpt_sum(struct yaffs_dev *dev) { - __u32 checkpt_sum0; - __u32 checkpt_sum1; + u32 checkpt_sum0; + u32 checkpt_sum1; int ok; yaffs2_get_checkpt_sum(dev, &checkpt_sum0); - ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == sizeof(checkpt_sum1)); + ok = (yaffs2_checkpt_rd(dev, &checkpt_sum1, sizeof(checkpt_sum1)) == + sizeof(checkpt_sum1)); if (!ok) return 0; @@ -664,13 +697,13 @@ static int yaffs2_rd_checkpt_sum(yaffs_dev_t *dev) return 1; } - -static int yaffs2_wr_checkpt_data(yaffs_dev_t *dev) +static int yaffs2_wr_checkpt_data(struct yaffs_dev *dev) { int ok = 1; if (!yaffs2_checkpt_required(dev)) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint write" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("skipping checkpoint write" TENDSTR))); ok = 0; } @@ -678,19 +711,23 @@ static int yaffs2_wr_checkpt_data(yaffs_dev_t *dev) ok = yaffs2_checkpt_open(dev, 1); if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint validity" TENDSTR))); ok = yaffs2_wr_checkpt_validity_marker(dev, 1); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint device" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint device" TENDSTR))); ok = yaffs2_wr_checkpt_dev(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint objects" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint objects" TENDSTR))); ok = yaffs2_wr_checkpt_objs(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("write checkpoint validity" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("write checkpoint validity" TENDSTR))); ok = yaffs2_wr_checkpt_validity_marker(dev, 0); } @@ -708,41 +745,47 @@ static int yaffs2_wr_checkpt_data(yaffs_dev_t *dev) return dev->is_checkpointed; } -static int yaffs2_rd_checkpt_data(yaffs_dev_t *dev) +static int yaffs2_rd_checkpt_data(struct yaffs_dev *dev) { int ok = 1; - - if(!dev->param.is_yaffs2) + + if (!dev->param.is_yaffs2) ok = 0; if (ok && dev->param.skip_checkpt_rd) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("skipping checkpoint read" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("skipping checkpoint read" TENDSTR))); ok = 0; } if (ok) - ok = yaffs2_checkpt_open(dev, 0); /* open for read */ + ok = yaffs2_checkpt_open(dev, 0); /* open for read */ if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs2_rd_checkpt_validty_marker(dev, 1); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint validity" TENDSTR))); + ok = yaffs2_rd_checkpt_validity_marker(dev, 1); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint device" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint device" TENDSTR))); ok = yaffs2_rd_checkpt_dev(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint objects" TENDSTR))); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint objects" TENDSTR))); ok = yaffs2_rd_checkpt_objs(dev); } if (ok) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs2_rd_checkpt_validty_marker(dev, 0); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint validity" TENDSTR))); + ok = yaffs2_rd_checkpt_validity_marker(dev, 0); } if (ok) { ok = yaffs2_rd_checkpt_sum(dev); - T(YAFFS_TRACE_CHECKPOINT, (TSTR("read checkpoint checksum %d" TENDSTR), ok)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("read checkpoint checksum %d" TENDSTR), ok)); } if (!yaffs_checkpt_close(dev)) @@ -757,10 +800,9 @@ static int yaffs2_rd_checkpt_data(yaffs_dev_t *dev) } -void yaffs2_checkpt_invalidate(yaffs_dev_t *dev) +void yaffs2_checkpt_invalidate(struct yaffs_dev *dev) { - if (dev->is_checkpointed || - dev->blocks_in_checkpt > 0) { + if (dev->is_checkpointed || dev->blocks_in_checkpt > 0) { dev->is_checkpointed = 0; yaffs2_checkpt_invalidate_stream(dev); } @@ -768,11 +810,12 @@ void yaffs2_checkpt_invalidate(yaffs_dev_t *dev) dev->param.sb_dirty_fn(dev); } - -int yaffs_checkpoint_save(yaffs_dev_t *dev) +int yaffs_checkpoint_save(struct yaffs_dev *dev) { - T(YAFFS_TRACE_CHECKPOINT, (TSTR("save entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("save entry: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); yaffs_verify_objects(dev); yaffs_verify_blocks(dev); @@ -783,15 +826,19 @@ int yaffs_checkpoint_save(yaffs_dev_t *dev) yaffs2_wr_checkpt_data(dev); } - T(YAFFS_TRACE_ALWAYS, (TSTR("save exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_ALWAYS, + (TSTR("save exit: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); return dev->is_checkpointed; } -int yaffs2_checkpt_restore(yaffs_dev_t *dev) +int yaffs2_checkpt_restore(struct yaffs_dev *dev) { int retval; - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore entry: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("restore entry: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); retval = yaffs2_rd_checkpt_data(dev); @@ -801,39 +848,40 @@ int yaffs2_checkpt_restore(yaffs_dev_t *dev) yaffs_verify_free_chunks(dev); } - T(YAFFS_TRACE_CHECKPOINT, (TSTR("restore exit: is_checkpointed %d"TENDSTR), dev->is_checkpointed)); + T(YAFFS_TRACE_CHECKPOINT, + (TSTR("restore exit: is_checkpointed %d" TENDSTR), + dev->is_checkpointed)); return retval; } -int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size) +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size) { /* if new_size > old_file_size. * We're going to be writing a hole. * If the hole is small then write zeros otherwise write a start of hole marker. */ - loff_t old_file_size; int increase; - int small_hole ; + int small_hole; int result = YAFFS_OK; - yaffs_dev_t *dev = NULL; + struct yaffs_dev *dev = NULL; + + u8 *local_buffer = NULL; - __u8 *local_buffer = NULL; - int small_increase_ok = 0; - - if(!obj) + + if (!obj) return YAFFS_FAIL; - if(obj->variant_type != YAFFS_OBJECT_TYPE_FILE) + if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE) return YAFFS_FAIL; - + dev = obj->my_dev; - + /* Bail out if not yaffs2 mode */ - if(!dev->param.is_yaffs2) + if (!dev->param.is_yaffs2) return YAFFS_OK; old_file_size = obj->variant.file_variant.file_size; @@ -843,46 +891,48 @@ int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size) increase = new_size - old_file_size; - if(increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk && - yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) + if (increase < YAFFS_SMALL_HOLE_THRESHOLD * dev->data_bytes_per_chunk && + yaffs_check_alloc_available(dev, YAFFS_SMALL_HOLE_THRESHOLD + 1)) small_hole = 1; else small_hole = 0; - if(small_hole) - local_buffer= yaffs_get_temp_buffer(dev, __LINE__); - - if(local_buffer){ + if (small_hole) + local_buffer = yaffs_get_temp_buffer(dev, __LINE__); + + if (local_buffer) { /* fill hole with zero bytes */ int pos = old_file_size; int this_write; int written; - memset(local_buffer,0,dev->data_bytes_per_chunk); + memset(local_buffer, 0, dev->data_bytes_per_chunk); small_increase_ok = 1; - while(increase > 0 && small_increase_ok){ + while (increase > 0 && small_increase_ok) { this_write = increase; - if(this_write > dev->data_bytes_per_chunk) + if (this_write > dev->data_bytes_per_chunk) this_write = dev->data_bytes_per_chunk; - written = yaffs_do_file_wr(obj,local_buffer,pos,this_write,0); - if(written == this_write){ + written = + yaffs_do_file_wr(obj, local_buffer, pos, this_write, + 0); + if (written == this_write) { pos += this_write; increase -= this_write; } else small_increase_ok = 0; } - yaffs_release_temp_buffer(dev,local_buffer,__LINE__); + yaffs_release_temp_buffer(dev, local_buffer, __LINE__); - /* If we were out of space then reverse any chunks we've added */ - if(!small_increase_ok) + /* If we were out of space then reverse any chunks we've added */ + if (!small_increase_ok) yaffs_resize_file_down(obj, old_file_size); } - + if (!small_increase_ok && - obj->parent && - obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED && - obj->parent->obj_id != YAFFS_OBJECTID_DELETED){ + obj->parent && + obj->parent->obj_id != YAFFS_OBJECTID_UNLINKED && + obj->parent->obj_id != YAFFS_OBJECTID_DELETED) { /* Write a hole start header with the old file size */ yaffs_update_oh(obj, NULL, 0, 1, 0, NULL); } @@ -891,28 +941,26 @@ int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size) } - -typedef struct { +struct yaffs_block_index { int seq; int block; -} yaffs_block_index; - +}; static int yaffs2_ybicmp(const void *a, const void *b) { - register int aseq = ((yaffs_block_index *)a)->seq; - register int bseq = ((yaffs_block_index *)b)->seq; - register int ablock = ((yaffs_block_index *)a)->block; - register int bblock = ((yaffs_block_index *)b)->block; + int aseq = ((struct yaffs_block_index *)a)->seq; + int bseq = ((struct yaffs_block_index *)b)->seq; + int ablock = ((struct yaffs_block_index *)a)->block; + int bblock = ((struct yaffs_block_index *)b)->block; if (aseq == bseq) return ablock - bblock; else return aseq - bseq; } -int yaffs2_scan_backwards(yaffs_dev_t *dev) +int yaffs2_scan_backwards(struct yaffs_dev *dev) { - yaffs_ext_tags tags; + struct yaffs_ext_tags tags; int blk; int block_iter; int start_iter; @@ -923,16 +971,16 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) int result; int c; int deleted; - yaffs_block_state_t state; - yaffs_obj_t *hard_list = NULL; - yaffs_block_info_t *bi; - __u32 seq_number; - yaffs_obj_header *oh; - yaffs_obj_t *in; - yaffs_obj_t *parent; + enum yaffs_block_state state; + struct yaffs_obj *hard_list = NULL; + struct yaffs_block_info *bi; + u32 seq_number; + struct yaffs_obj_hdr *oh; + struct yaffs_obj *in; + struct yaffs_obj *parent; int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; int is_unlinked; - __u8 *chunk_data; + u8 *chunk_data; int file_size; int is_shrink; @@ -940,8 +988,7 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) int equiv_id; int alloc_failed = 0; - - yaffs_block_index *block_index = NULL; + struct yaffs_block_index *block_index = NULL; int alt_block_index = 0; T(YAFFS_TRACE_SCAN, @@ -949,19 +996,21 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) ("yaffs2_scan_backwards starts intstartblk %d intendblk %d..." TENDSTR), dev->internal_start_block, dev->internal_end_block)); - dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; - block_index = YMALLOC(n_blocks * sizeof(yaffs_block_index)); + block_index = YMALLOC(n_blocks * sizeof(struct yaffs_block_index)); if (!block_index) { - block_index = YMALLOC_ALT(n_blocks * sizeof(yaffs_block_index)); + block_index = + YMALLOC_ALT(n_blocks * sizeof(struct yaffs_block_index)); alt_block_index = 1; } if (!block_index) { T(YAFFS_TRACE_SCAN, - (TSTR("yaffs2_scan_backwards() could not allocate block index!" TENDSTR))); + (TSTR + ("yaffs2_scan_backwards() could not allocate block index!" + TENDSTR))); return YAFFS_FAIL; } @@ -971,7 +1020,8 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) /* Scan all the blocks to determine their state */ bi = dev->block_info; - for (blk = dev->internal_start_block; blk <= dev->internal_end_block; blk++) { + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; + blk++) { yaffs_clear_chunk_bits(dev, blk); bi->pages_in_use = 0; bi->soft_del_pages = 0; @@ -990,7 +1040,6 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, state, seq_number)); - if (state == YAFFS_BLOCK_STATE_CHECKPOINT) { dev->blocks_in_checkpt++; @@ -1028,14 +1077,13 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) } T(YAFFS_TRACE_SCAN, - (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan)); - - + (TSTR("%d blocks to be sorted..." TENDSTR), n_to_scan)); YYIELD(); - /* Sort the blocks by sequence number*/ - yaffs_qsort(block_index, n_to_scan, sizeof(yaffs_block_index), yaffs2_ybicmp); + /* Sort the blocks by sequence number */ + yaffs_sort(block_index, n_to_scan, sizeof(struct yaffs_block_index), + yaffs2_ybicmp); YYIELD(); @@ -1049,7 +1097,7 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) /* For each block.... backwards */ for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter; - block_iter--) { + block_iter--) { /* Cooperative multitasking! This loop can run for so long that watchdog timers expire. */ YYIELD(); @@ -1059,7 +1107,6 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) bi = yaffs_get_block_info(dev, blk); - state = bi->block_state; deleted = 0; @@ -1077,7 +1124,7 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) chunk = blk * dev->param.chunks_per_block + c; result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, - &tags); + &tags); /* Let's have a good look at this chunk... */ @@ -1098,9 +1145,12 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) state = YAFFS_BLOCK_STATE_EMPTY; dev->n_erased_blocks++; } else { - if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - state == YAFFS_BLOCK_STATE_ALLOCATING) { - if (dev->seq_number == bi->seq_number) { + if (state == + YAFFS_BLOCK_STATE_NEEDS_SCANNING + || state == + YAFFS_BLOCK_STATE_ALLOCATING) { + if (dev->seq_number == + bi->seq_number) { /* this is the block being allocated from */ T(YAFFS_TRACE_SCAN, @@ -1108,18 +1158,22 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) (" Allocating from %d %d" TENDSTR), blk, c)); - state = YAFFS_BLOCK_STATE_ALLOCATING; + state = + YAFFS_BLOCK_STATE_ALLOCATING; dev->alloc_block = blk; dev->alloc_page = c; - dev->alloc_block_finder = blk; + dev-> + alloc_block_finder = + blk; } else { /* This is a partially written block that is not * the current allocation block. */ - T(YAFFS_TRACE_SCAN, - (TSTR("Partially written block %d detected" TENDSTR), - blk)); + T(YAFFS_TRACE_SCAN, + (TSTR + ("Partially written block %d detected" + TENDSTR), blk)); } } } @@ -1128,37 +1182,40 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) } else if (tags.ecc_result == YAFFS_ECC_RESULT_UNFIXED) { T(YAFFS_TRACE_SCAN, - (TSTR(" Unfixed ECC in chunk(%d:%d), chunk ignored"TENDSTR), - blk, c)); + (TSTR + (" Unfixed ECC in chunk(%d:%d), chunk ignored" + TENDSTR), blk, c)); - dev->n_free_chunks++; + dev->n_free_chunks++; } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID || - tags.chunk_id > YAFFS_MAX_CHUNK_ID || - (tags.chunk_id > 0 && tags.n_bytes > dev->data_bytes_per_chunk) || - tags.seq_number != bi->seq_number ) { + tags.chunk_id > YAFFS_MAX_CHUNK_ID || + (tags.chunk_id > 0 + && tags.n_bytes > dev->data_bytes_per_chunk) + || tags.seq_number != bi->seq_number) { T(YAFFS_TRACE_SCAN, - (TSTR("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored"TENDSTR), - blk, c,tags.obj_id, tags.chunk_id, tags.n_bytes)); + (TSTR + ("Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored" + TENDSTR), blk, c, tags.obj_id, + tags.chunk_id, tags.n_bytes)); - dev->n_free_chunks++; + dev->n_free_chunks++; } else if (tags.chunk_id > 0) { /* chunk_id > 0 so it is a data chunk... */ unsigned int endpos; - __u32 chunk_base = - (tags.chunk_id - 1) * dev->data_bytes_per_chunk; + u32 chunk_base = + (tags.chunk_id - + 1) * dev->data_bytes_per_chunk; found_chunks = 1; - yaffs_set_chunk_bit(dev, blk, c); bi->pages_in_use++; in = yaffs_find_or_create_by_number(dev, - tags. - obj_id, - YAFFS_OBJECT_TYPE_FILE); + tags.obj_id, + YAFFS_OBJECT_TYPE_FILE); if (!in) { /* Out of memory */ alloc_failed = 1; @@ -1166,9 +1223,11 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) if (in && in->variant_type == YAFFS_OBJECT_TYPE_FILE - && chunk_base < in->variant.file_variant.shrink_size) { + && chunk_base < + in->variant.file_variant.shrink_size) { /* This has not been invalidated by a resize */ - if (!yaffs_put_chunk_in_file(in, tags.chunk_id, chunk, -1)) { + if (!yaffs_put_chunk_in_file + (in, tags.chunk_id, chunk, -1)) { alloc_failed = 1; } @@ -1178,15 +1237,19 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) endpos = chunk_base + tags.n_bytes; if (!in->valid && /* have not got an object header yet */ - in->variant.file_variant.scanned_size < endpos) { - in->variant.file_variant.scanned_size = endpos; - in->variant.file_variant.file_size = endpos; + in->variant.file_variant. + scanned_size < endpos) { + in->variant.file_variant. + scanned_size = endpos; + in->variant.file_variant. + file_size = endpos; } } else if (in) { /* This chunk has been invalidated by a resize, or a past file deletion * so delete the chunk*/ - yaffs_chunk_del(dev, chunk, 1, __LINE__); + yaffs_chunk_del(dev, chunk, 1, + __LINE__); } } else { @@ -1203,18 +1266,23 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) if (tags.extra_available) { in = yaffs_find_or_create_by_number(dev, - tags.obj_id, - tags.extra_obj_type); + tags. + obj_id, + tags. + extra_obj_type); if (!in) alloc_failed = 1; } if (!in || - (!in->valid && dev->param.disable_lazy_load) || - tags.extra_shadows || - (!in->valid && - (tags.obj_id == YAFFS_OBJECTID_ROOT || - tags.obj_id == YAFFS_OBJECTID_LOSTNFOUND))) { + (!in->valid && dev->param.disable_lazy_load) + || tags.extra_shadows || (!in->valid + && (tags.obj_id == + YAFFS_OBJECTID_ROOT + || tags. + obj_id == + YAFFS_OBJECTID_LOSTNFOUND))) + { /* If we don't have valid info then we need to read the chunk * TODO In future we can probably defer reading the chunk and @@ -1222,16 +1290,18 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) */ result = yaffs_rd_chunk_tags_nand(dev, - chunk, - chunk_data, - NULL); + chunk, + chunk_data, + NULL); - oh = (yaffs_obj_header *) chunk_data; + oh = (struct yaffs_obj_hdr *)chunk_data; if (dev->param.inband_tags) { /* Fix up the header if they got corrupted by inband tags */ - oh->shadows_obj = oh->inband_shadowed_obj_id; - oh->is_shrink = oh->inband_is_shrink; + oh->shadows_obj = + oh->inband_shadowed_obj_id; + oh->is_shrink = + oh->inband_is_shrink; } if (!in) { @@ -1257,23 +1327,34 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) * we first have to suck out resize info if it is a file. */ - if ((in->variant_type == YAFFS_OBJECT_TYPE_FILE) && - ((oh && - oh->type == YAFFS_OBJECT_TYPE_FILE) || - (tags.extra_available && - tags.extra_obj_type == YAFFS_OBJECT_TYPE_FILE))) { - __u32 this_size = - (oh) ? oh->file_size : tags. - extra_length; - __u32 parent_obj_id = + if ((in->variant_type == + YAFFS_OBJECT_TYPE_FILE) && ((oh + && + oh-> + type + == + YAFFS_OBJECT_TYPE_FILE) + || + (tags. + extra_available + && + tags. + extra_obj_type + == + YAFFS_OBJECT_TYPE_FILE))) + { + u32 this_size = (oh) ? oh-> - parent_obj_id : tags. - extra_parent_id; - + file_size : + tags.extra_length; + u32 parent_obj_id = + (oh) ? oh->parent_obj_id : + tags.extra_parent_id; is_shrink = - (oh) ? oh->is_shrink : tags. - extra_is_shrink; + (oh) ? oh-> + is_shrink : + tags.extra_is_shrink; /* If it is deleted (unlinked at start also means deleted) * we treat the file size as being zeroed at this point. @@ -1286,28 +1367,36 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) is_shrink = 1; } - if (is_shrink && in->variant.file_variant.shrink_size > this_size) - in->variant.file_variant.shrink_size = this_size; + if (is_shrink + && in->variant.file_variant. + shrink_size > this_size) + in->variant. + file_variant. + shrink_size = + this_size; if (is_shrink) bi->has_shrink_hdr = 1; } /* Use existing - destroy this one. */ - yaffs_chunk_del(dev, chunk, 1, __LINE__); + yaffs_chunk_del(dev, chunk, 1, + __LINE__); } if (!in->valid && in->variant_type != (oh ? oh->type : tags.extra_obj_type)) - T(YAFFS_TRACE_ERROR, ( - TSTR("yaffs tragedy: Bad object type, " - TCONT("%d != %d, for object %d at chunk ") + T(YAFFS_TRACE_ERROR, + (TSTR + ("yaffs tragedy: Bad object type, " + TCONT + ("%d != %d, for object %d at chunk ") TCONT("%d during scan") - TENDSTR), oh ? - oh->type : tags.extra_obj_type, - in->variant_type, tags.obj_id, - chunk)); + TENDSTR), oh ? + oh->type : tags.extra_obj_type, + in->variant_type, tags.obj_id, + chunk)); if (!in->valid && (tags.obj_id == YAFFS_OBJECTID_ROOT || @@ -1319,24 +1408,8 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) if (oh) { in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; - + yaffs_load_attribs(in, oh); in->lazy_loaded = 0; - -#endif } else in->lazy_loaded = 1; @@ -1352,49 +1425,36 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) in->variant_type = oh->type; in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; -#endif + yaffs_load_attribs(in, oh); if (oh->shadows_obj > 0) - yaffs_handle_shadowed_obj(dev, - oh-> - shadows_obj, - 1); - - + yaffs_handle_shadowed_obj + (dev, + oh->shadows_obj, + 1); - yaffs_set_obj_name_from_oh(in, oh); + yaffs_set_obj_name_from_oh(in, + oh); parent = yaffs_find_or_create_by_number - (dev, oh->parent_obj_id, - YAFFS_OBJECT_TYPE_DIRECTORY); + (dev, oh->parent_obj_id, + YAFFS_OBJECT_TYPE_DIRECTORY); - file_size = oh->file_size; - is_shrink = oh->is_shrink; - equiv_id = oh->equiv_id; + file_size = oh->file_size; + is_shrink = oh->is_shrink; + equiv_id = oh->equiv_id; } else { - in->variant_type = tags.extra_obj_type; + in->variant_type = + tags.extra_obj_type; parent = yaffs_find_or_create_by_number - (dev, tags.extra_parent_id, - YAFFS_OBJECT_TYPE_DIRECTORY); - file_size = tags.extra_length; - is_shrink = tags.extra_is_shrink; - equiv_id = tags.extra_equiv_id; + (dev, tags.extra_parent_id, + YAFFS_OBJECT_TYPE_DIRECTORY); + file_size = tags.extra_length; + is_shrink = + tags.extra_is_shrink; + equiv_id = tags.extra_equiv_id; in->lazy_loaded = 1; } @@ -1411,12 +1471,13 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) YAFFS_OBJECT_TYPE_UNKNOWN) { /* Set up as a directory */ parent->variant_type = - YAFFS_OBJECT_TYPE_DIRECTORY; - YINIT_LIST_HEAD(&parent->variant. - dir_variant. - children); - } else if (!parent || parent->variant_type != - YAFFS_OBJECT_TYPE_DIRECTORY) { + YAFFS_OBJECT_TYPE_DIRECTORY; + INIT_LIST_HEAD(&parent-> + variant.dir_variant.children); + } else if (!parent + || parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) + { /* Hoosterman, another problem.... * We're trying to use a non-directory as a directory */ @@ -1430,8 +1491,8 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) yaffs_add_obj_to_dir(parent, in); - is_unlinked = (parent == dev->del_dir) || - (parent == dev->unlinked_dir); + is_unlinked = (parent == dev->del_dir) + || (parent == dev->unlinked_dir); if (is_shrink) { /* Mark the block as having a shrink header */ @@ -1451,28 +1512,40 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) break; case YAFFS_OBJECT_TYPE_FILE: - if (in->variant.file_variant. - scanned_size < file_size) { + if (in->variant. + file_variant.scanned_size < + file_size) { /* This covers the case where the file size is greater * than where the data is * This will happen if the file is resized to be larger * than its current data extents. */ - in->variant.file_variant.file_size = file_size; - in->variant.file_variant.scanned_size = file_size; + in->variant. + file_variant. + file_size = + file_size; + in->variant. + file_variant. + scanned_size = + file_size; } - if (in->variant.file_variant.shrink_size > file_size) - in->variant.file_variant.shrink_size = file_size; - + if (in->variant.file_variant. + shrink_size > file_size) + in->variant. + file_variant. + shrink_size = + file_size; break; case YAFFS_OBJECT_TYPE_HARDLINK: if (!is_unlinked) { - in->variant.hardlink_variant.equiv_id = - equiv_id; + in->variant. + hardlink_variant. + equiv_id = equiv_id; in->hard_links.next = - (struct ylist_head *) hard_list; + (struct list_head *) + hard_list; hard_list = in; } break; @@ -1484,10 +1557,16 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) break; case YAFFS_OBJECT_TYPE_SYMLINK: if (oh) { - in->variant.symlink_variant.alias = - yaffs_clone_str(oh->alias); - if (!in->variant.symlink_variant.alias) - alloc_failed = 1; + in->variant. + symlink_variant. + alias = + yaffs_clone_str(oh-> + alias); + if (!in->variant. + symlink_variant. + alias) + alloc_failed = + 1; } break; } @@ -1496,14 +1575,13 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) } - } /* End of scanning for each chunk */ + } /* End of scanning for each chunk */ if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { /* If we got this far while scanning, then the block is fully allocated. */ state = YAFFS_BLOCK_STATE_FULL; } - bi->block_state = state; /* Now let's see if it was dirty */ @@ -1514,7 +1592,7 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) } } - + yaffs_skip_rest_of_block(dev); if (alt_block_index) @@ -1529,7 +1607,6 @@ int yaffs2_scan_backwards(yaffs_dev_t *dev) */ yaffs_link_fixup(dev, hard_list); - yaffs_release_temp_buffer(dev, chunk_data, __LINE__); if (alloc_failed) diff --git a/yaffs_yaffs2.h b/yaffs_yaffs2.h index ce1fa9d..e1a9287 100644 --- a/yaffs_yaffs2.h +++ b/yaffs_yaffs2.h @@ -18,21 +18,22 @@ #include "yaffs_guts.h" -void yaffs_calc_oldest_dirty_seq(yaffs_dev_t *dev); -void yaffs2_find_oldest_dirty_seq(yaffs_dev_t *dev); -void yaffs2_clear_oldest_dirty_seq(yaffs_dev_t *dev, yaffs_block_info_t *bi); -void yaffs2_update_oldest_dirty_seq(yaffs_dev_t *dev, unsigned block_no, yaffs_block_info_t *bi); -int yaffs_block_ok_for_gc(yaffs_dev_t *dev, yaffs_block_info_t *bi); -__u32 yaffs2_find_refresh_block(yaffs_dev_t *dev); -int yaffs2_checkpt_required(yaffs_dev_t *dev); -int yaffs_calc_checkpt_blocks_required(yaffs_dev_t *dev); +void yaffs_calc_oldest_dirty_seq(struct yaffs_dev *dev); +void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev); +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, + struct yaffs_block_info *bi); +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *bi); +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi); +u32 yaffs2_find_refresh_block(struct yaffs_dev *dev); +int yaffs2_checkpt_required(struct yaffs_dev *dev); +int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev); +void yaffs2_checkpt_invalidate(struct yaffs_dev *dev); +int yaffs2_checkpt_save(struct yaffs_dev *dev); +int yaffs2_checkpt_restore(struct yaffs_dev *dev); -void yaffs2_checkpt_invalidate(yaffs_dev_t *dev); -int yaffs2_checkpt_save(yaffs_dev_t *dev); -int yaffs2_checkpt_restore(yaffs_dev_t *dev); - -int yaffs2_handle_hole(yaffs_obj_t *obj, loff_t new_size); -int yaffs2_scan_backwards(yaffs_dev_t *dev); +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size); +int yaffs2_scan_backwards(struct yaffs_dev *dev); #endif diff --git a/yportenv.h b/yportenv_multi.h similarity index 95% rename from yportenv.h rename to yportenv_multi.h index 38a3595..ec43fd5 100644 --- a/yportenv.h +++ b/yportenv_multi.h @@ -13,7 +13,6 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - #ifndef __YPORTENV_H__ #define __YPORTENV_H__ @@ -41,7 +40,7 @@ #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 19)) #include #endif - +#include #include #include #include @@ -49,6 +48,11 @@ #include #include #include +#include +#include +#include +#include +#include #define YCHAR char #define YUCHAR unsigned char @@ -60,6 +64,7 @@ #define yaffs_strnlen(s,m) strnlen(s,m) #define yaffs_sprintf sprintf #define yaffs_toupper(a) toupper(a) +#define yaffs_sort(base, n, sz, cmp_fn) sort(base, n, sz, cmp_fn, NULL) #define Y_INLINE __inline__ @@ -113,7 +118,6 @@ #include "stdio.h" #include "string.h" - #define YMALLOC(x) malloc(x) #define YFREE(x) free(x) #define YMALLOC_ALT(x) malloc(x) @@ -170,7 +174,7 @@ #define O_RDWR 02 #endif -#ifndef O_CREAT +#ifndef O_CREAT #define O_CREAT 0100 #endif @@ -222,7 +226,7 @@ #define EACCES 13 #endif -#ifndef EXDEV +#ifndef EXDEV #define EXDEV 18 #endif @@ -266,7 +270,6 @@ #define EISDIR 21 #endif - // Mode flags #ifndef S_IFMT @@ -285,7 +288,7 @@ #define S_IFREG 0100000 #endif -#ifndef S_IREAD +#ifndef S_IREAD #define S_IREAD 0000400 #endif @@ -333,5 +336,4 @@ } while (0) #endif - #endif diff --git a/yportenv_single.h b/yportenv_single.h new file mode 100644 index 0000000..2eae429 --- /dev/null +++ b/yportenv_single.h @@ -0,0 +1,90 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2010 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 2.1 as + * published by the Free Software Foundation. + * + * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. + */ + +#ifndef __YPORTENV_LINUX_H__ +#define __YPORTENV_LINUX_H__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define YCHAR char +#define YUCHAR unsigned char +#define _Y(x) x +#define yaffs_strcat(a, b) strcat(a, b) +#define yaffs_strcpy(a, b) strcpy(a, b) +#define yaffs_strncpy(a, b, c) strncpy(a, b, c) +#define yaffs_strncmp(a, b, c) strncmp(a, b, c) +#define yaffs_strnlen(s,m) strnlen(s,m) +#define yaffs_sprintf sprintf +#define yaffs_toupper(a) toupper(a) + +#define yaffs_sort(base, n, sz, cmp_fn) sort(base, n, sz, cmp_fn, NULL) + +#define Y_INLINE __inline__ + +#define YAFFS_LOSTNFOUND_NAME "lost+found" +#define YAFFS_LOSTNFOUND_PREFIX "obj" + +#define YMALLOC(x) kmalloc(x, GFP_NOFS) +#define YFREE(x) kfree(x) +#define YMALLOC_ALT(x) vmalloc(x) +#define YFREE_ALT(x) vfree(x) +#define YMALLOC_DMA(x) YMALLOC(x) + +#define YYIELD() schedule() +#define Y_DUMP_STACK() dump_stack() + +#define YAFFS_ROOT_MODE 0755 +#define YAFFS_LOSTNFOUND_MODE 0700 + +#define Y_CURRENT_TIME CURRENT_TIME.tv_sec +#define Y_TIME_CONVERT(x) (x).tv_sec + +#define yaffs_sum_cmp(x, y) ((x) == (y)) +#define yaffs_strcmp(a, b) strcmp(a, b) + +#define TENDSTR "\n" +#define TSTR(x) KERN_DEBUG x +#define TCONT(x) x +#define TOUT(p) printk p + +#define compile_time_assertion(assertion) \ + ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; }) + +#ifndef Y_DUMP_STACK +#define Y_DUMP_STACK() do { } while (0) +#endif + +#ifndef YBUG +#define YBUG() do {\ + T(YAFFS_TRACE_BUG,\ + (TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),\ + __LINE__));\ + Y_DUMP_STACK();\ +} while (0) +#endif + +#endif