Staging: Add yaffs2 filesystem
cover Staging: Add yaffs2 filesystem
The patch sets puts the yaffs2 filesystem in the staging directory.
It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
PATCH 1/29 Staging: Add yaffs2 support
Changed files so that it could be compiled with yaffs2 enabled.
--- drivers/staging/Kconfig | 2 ++ drivers/staging/Makefile | 1 + 2 files changed, 3 insertions(+), 0 deletions(-)
drivers/staging/Kconfig +2 -0
@@ -93,6 +93,8 @@ source "drivers/staging/pohmelfs/Kconfig" source "drivers/staging/autofs/Kconfig" +source "drivers/staging/yaffs2/Kconfig" + source "drivers/staging/phison/Kconfig" source "drivers/staging/line6/Kconfig"
drivers/staging/Makefile +1 -0
@@ -31,6 +31,7 @@ obj-$(CONFIG_TRANZPORT) += frontier/ obj-$(CONFIG_DREAM) += dream/ obj-$(CONFIG_POHMELFS) += pohmelfs/ obj-$(CONFIG_AUTOFS_FS) += autofs/ +obj-$(CONFIG_YAFFS_FS) += yaffs2/ obj-$(CONFIG_IDE_PHISON) += phison/ obj-$(CONFIG_LINE6_USB) += line6/ obj-$(CONFIG_USB_SERIAL_QUATECH2) += serqt_usb2/
Signature · 1 line
1.7.3.2.146.gca209
PATCH 2/29 Staging: yaffs2: Add Makefile and Kconfig files
In reply to Tracey DentAdd Makefile and Kconfig files so that we can start to compile the filesystem.
--- drivers/staging/yaffs2/Kconfig | 190 +++++++++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/Makefile | 18 ++++ 2 files changed, 208 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/Kconfig create mode 100644 drivers/staging/yaffs2/Makefile
drivers/staging/yaffs2/Kconfig new file +190 -0
@@ -0,0 +1,190 @@ +# +# YAFFS file system configurations +# + +config YAFFS_FS + tristate "YAFFS2 file system support" + default n + depends on MTD_BLOCK + select YAFFS_YAFFS1 + select YAFFS_YAFFS2 + help + YAFFS2, or Yet Another Flash Filing System, is a filing system + optimised for NAND Flash chips. + + To compile the YAFFS2 file system support as a module, choose M + here: the module will be called yaffs2. + + If unsure, say N. + + Further information on YAFFS2 is available at + <http://www.aleph1.co.uk/yaffs/>. + +config YAFFS_YAFFS1 + bool "512 byte / page devices" + depends on YAFFS_FS + default y + help + Enable YAFFS1 support -- yaffs for 512 byte / page devices + + Not needed for 2K-page devices. + + If unsure, say Y. + +config YAFFS_9BYTE_TAGS + bool "Use older-style on-NAND data format with pageStatus byte" + depends on YAFFS_YAFFS1 + default n + help + + Older-style on-NAND data format has a "pageStatus" byte to record + chunk/page state. This byte is zero when the page is discarded. + Choose this option if you have existing on-NAND data using this + format that you need to continue to support. New data written + also uses the older-style format. Note: Use of this option + generally requires that MTD's oob layout be adjusted to use the + older-style format. See notes on tags formats and MTD versions + in yaffs_mtdif1.c. + + If unsure, say N. + +config YAFFS_DOES_ECC + bool "Lets Yaffs do its own ECC" + depends on YAFFS_FS && YAFFS_YAFFS1 && !YAFFS_9BYTE_TAGS + default n + help + This enables Yaffs to use its own ECC functions instead of using + the ones from the generic MTD-NAND driver. + + If unsure, say N. + +config YAFFS_ECC_WRONG_ORDER + bool "Use the same ecc byte order as Steven Hill's nand_ecc.c" + depends on YAFFS_FS && YAFFS_DOES_ECC && !YAFFS_9BYTE_TAGS + default n + help + This makes yaffs_ecc.c use the same ecc byte order as Steven + Hill's nand_ecc.c. If not set, then you get the same ecc byte + order as SmartMedia. + + If unsure, say N. + +config YAFFS_YAFFS2 + bool "2048 byte (or larger) / page devices" + depends on YAFFS_FS + default y + help + Enable YAFFS2 support -- yaffs for >= 2K bytes per page devices + + If unsure, say Y. + +config YAFFS_AUTO_YAFFS2 + bool "Autoselect yaffs2 format" + depends on YAFFS_YAFFS2 + default y + help + Without this, you need to explicitely use yaffs2 as the file + system type. With this, you can say "yaffs" and yaffs or yaffs2 + will be used depending on the device page size (yaffs on + 512-byte page devices, yaffs2 on 2K page devices). + + If unsure, say Y. + +config YAFFS_DISABLE_TAGS_ECC + bool "Disable YAFFS from doing ECC on tags by default" + depends on YAFFS_FS && YAFFS_YAFFS2 + default n + help + This defaults Yaffs to using its own ECC calculations on tags instead of + just relying on the MTD. + This behavior can also be overridden with tags_ecc_on and + tags_ecc_off mount options. + + If unsure, say N. + + +config YAFFS_DISABLE_WIDE_TNODES + bool "Turn off wide tnodes" + depends on YAFFS_FS + default n + help + Wide tnodes are only used for NAND arrays >=32MB for 512-byte + page devices and >=128MB for 2k page devices. They use slightly + more RAM but are faster since they eliminate chunk group + searching. + + Setting this to 'y' will force tnode width to 16 bits and save + memory but make large arrays slower. + + If unsure, say N. + +config YAFFS_ALWAYS_CHECK_CHUNK_ERASED + bool "Force chunk erase check" + depends on YAFFS_FS + default n + help + Normally YAFFS only checks chunks before writing until an erased + chunk is found. This helps to detect any partially written + chunks that might have happened due to power loss. + + Enabling this forces on the test that chunks are erased in flash + before writing to them. This takes more time but is potentially + a bit more secure. + + Suggest setting Y during development and ironing out driver + issues etc. Suggest setting to N if you want faster writing. + + If unsure, say Y. + +config YAFFS_SHORT_NAMES_IN_RAM + bool "Cache short names in RAM" + depends on YAFFS_FS + default y + help + If this config is set, then short names are stored with the + yaffs_Object. This costs an extra 16 bytes of RAM per object, + but makes look-ups faster. + + If unsure, say Y. + +config YAFFS_EMPTY_LOST_AND_FOUND + bool "Empty lost and found on boot" + depends on YAFFS_FS + default n + help + If this is enabled then the contents of lost and found is + automatically dumped at mount. + + If unsure, say N. + +config YAFFS_DISABLE_BLOCK_REFRESHING + bool "Disable yaffs2 block refreshing" + depends on YAFFS_FS + default n + help + If this is set, then block refreshing is disabled. + Block refreshing infrequently refreshes the oldest block in + a yaffs2 file system. This mechanism helps to refresh flash to + mitigate against data loss. This is particularly useful for MLC. + + If unsure, say N. + +config YAFFS_DISABLE_BACKGROUND + bool "Disable yaffs2 background processing" + depends on YAFFS_FS + default n + help + If this is set, then background processing is disabled. + Background processing makes many foreground activities faster. + + If unsure, say N. + +config YAFFS_XATTR + bool "Enable yaffs2 xattr support" + depends on YAFFS_FS + default y + help + If this is set then yaffs2 will provide xattr support. + If unsure, say Y. + +
drivers/staging/yaffs2/Makefile new file +18 -0
@@ -0,0 +1,18 @@ +# +# Makefile for the linux YAFFS filesystem routines. +# + +obj-$(CONFIG_YAFFS_FS) += yaffs.o + +yaffs-y := yaffs_ecc.o yaffs_vfs_glue.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_allocator.o +yaffs-y += yaffs_yaffs1.o +yaffs-y += yaffs_yaffs2.o +yaffs-y += yaffs_bitmap.o +yaffs-y += yaffs_verify.o + +
Signature · 1 line
1.7.3.2.146.gca209
PATCH 3/29 Staging: yaffs2: devextras.h: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/devextras.h | 101 ++++++++++++++++++++++++++++++++++++ 1 files changed, 101 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/devextras.h
drivers/staging/yaffs2/devextras.h new file +101 -0
@@ -0,0 +1,101 @@ +/* +* 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 <[email protected]> +* +* 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 <sys/stat.h> +#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 <sys/stat.h> +#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 <linux/types.h> +#include <linux/fs.h> +#include <linux/stat.h> + +#endif + + +#endif
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 03/29] Staging: yaffs2: devextras.h: Add file
Quoted 25 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/devextras.h | 101 ++++++++++++++++++++++++++++++++++++1 files changed, 101 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/devextras.hdrivers/staging/yaffs2/devextras.h new file +11
-0@@ -0,0 +1,101 @@ +/* +* 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 <[email protected]> +* +* 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.
drivers/staging/yaffs2/devextras.h line 21
Quoted 10 lines
drivers/staging/yaffs2/devextras.h new file +10
-0+* +* 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. +* +*/
Seriously, you're adding WIN32 #ifdefs. Why do we want to merge this header to mainline?
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 03/29] Staging: yaffs2: devextras.h: Add file
Quoted 31 lines · Pekka Enberg
Quoted 30 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
?drivers/staging/yaffs2/devextras.h | ?101 ++++++++++++++++++++++++++++++++++++ ?1 files changed, 101 insertions(+), 0 deletions(-)
?create mode 100644drivers/staging/yaffs2/devextras.hdrivers/staging/yaffs2/devextras.h new file +16
-0@@ -0,0 +1,101 @@ +/* +* 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 <[email protected]> +* +* 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. +*/ + +/*
Quoted 8 lines
drivers/staging/yaffs2/devextras.h line 21
Quoted 5 lines
drivers/staging/yaffs2/devextras.h new file +5
-0+* 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. +* +*/ Seriously, you're adding WIN32 #ifdefs. Why do we want to merge this header to mainline?
It would be in staging, and removed before going to the main portion of the tree. This happens all the time...
thanks,
greg k-h
PATCH 4/29 Staging: yaffs2: moduleconfig.h: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/moduleconfig.h | 86 +++++++++++++++++++++++++++++++++ 1 files changed, 86 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/moduleconfig.h
drivers/staging/yaffs2/moduleconfig.h new file +86 -0
@@ -0,0 +1,86 @@ +/* +* 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 Martin Fouts <[email protected]> +* +* 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 __YAFFS_CONFIG_H__ +#define __YAFFS_CONFIG_H__ + +#ifdef YAFFS_OUT_OF_TREE + +/* DO NOT UNSET THESE THREE. YAFFS2 will not compile if you do. */ +#define CONFIG_YAFFS_FS +#define CONFIG_YAFFS_YAFFS1 +#define CONFIG_YAFFS_YAFFS2 + +/* These options are independent of each other. Select those that matter. */ + +/* Default: Not selected */ +/* Meaning: Yaffs does its own ECC, rather than using MTD ECC */ +/* #define CONFIG_YAFFS_DOES_ECC */ + +/* Default: Selected */ +/* Meaning: Yaffs does its own ECC on tags for packed tags rather than use mtd */ +#define CONFIG_YAFFS_DOES_TAGS_ECC + +/* Default: Not selected */ +/* Meaning: ECC byte order is 'wrong'. Only meaningful if */ +/* CONFIG_YAFFS_DOES_ECC is set */ +/* #define CONFIG_YAFFS_ECC_WRONG_ORDER */ + +/* Default: Not selected */ +/* Meaning: Always test whether chunks are erased before writing to them. +Use during mtd debugging and init. */ +/* #define CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED */ + +/* Default: Not Selected */ +/* Meaning: At mount automatically empty all files from lost and found. */ +/* This is done to fix an old problem where rmdir was not checking for an */ +/* empty directory. This can also be achieved with a mount option. */ +#define CONFIG_YAFFS_EMPTY_LOST_AND_FOUND + +/* Default: Selected */ +/* Meaning: Cache short names, taking more RAM, but faster look-ups */ +#define CONFIG_YAFFS_SHORT_NAMES_IN_RAM + +/* Default: Unselected */ +/* Meaning: Select to disable block refreshing. */ +/* Block Refreshing periodically rewrites the oldest block. */ +/* #define CONFIG_DISABLE_BLOCK_REFRESHING */ + +/* Default: Unselected */ +/* Meaning: Select to disable background processing */ +/* #define CONFIG_DISABLE_BACKGROUND */ + + +/* Default: Selected */ +/* Meaning: Enable XATTR support */ +#define CONFIG_YAFFS_XATTR + +/* +Older-style on-NAND data format has a "page_status" byte to record +chunk/page state. This byte is zeroed when the page is discarded. +Choose this option if you have existing on-NAND data in this format +that you need to continue to support. New data written also uses the +older-style format. +Note: Use of this option generally requires that MTD's oob layout be +adjusted to use the older-style format. See notes on tags formats and +MTD versions in yaffs_mtdif1.c. +*/ +/* Default: Not selected */ +/* Meaning: Use older-style on-NAND data format with page_status byte */ +/* #define CONFIG_YAFFS_9BYTE_TAGS */ + +#endif /* YAFFS_OUT_OF_TREE */ + +#endif /* __YAFFS_CONFIG_H__ */
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 04/29] Staging: yaffs2: moduleconfig.h: Add file
Quoted 23 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/moduleconfig.h | 86 +++++++++++++++++++++++++++++++++1 files changed, 86 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/moduleconfig.hdrivers/staging/yaffs2/moduleconfig.h new file +9
-0@@ -0,0 +1,86 @@ +/* +* 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 Martin Fouts <[email protected]> +* +* This program is free software; you can redistribute it and/or modify
drivers/staging/yaffs2/moduleconfig.h line 19
Quoted 10 lines
drivers/staging/yaffs2/moduleconfig.h new file +10
-0+* 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 __YAFFS_CONFIG_H__ +#define __YAFFS_CONFIG_H__ + +#ifdef YAFFS_OUT_OF_TREE
You probably want to drop this header as well...
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 04/29] Staging: yaffs2: moduleconfig.h: Add file
Quoted 32 lines · Pekka Enberg
Quoted 31 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>--- drivers/staging/yaffs2/moduleconfig.h | 86 +++++++++++++++++++++++++++++++++ 1 files changed, 86 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/moduleconfig.hdrivers/staging/yaffs2/moduleconfig.h new file +2
-0@@ -0,0 +1,86 @@ +/* +* 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 Martin Fouts <[email protected]>
+ *
+ * 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.
Quoted 9 lines
drivers/staging/yaffs2/moduleconfig.h line 19
Quoted 6 lines
+ */
drivers/staging/yaffs2/moduleconfig.h new file +5
-0+ +#ifndef __YAFFS_CONFIG_H__ +#define __YAFFS_CONFIG_H__ + +#ifdef YAFFS_OUT_OF_TREE You probably want to drop this header as well...
Yes, I was going to make up a clean up patch set when or if this gets merge.
PATCH 5/29 Staging: yaffs2: yaffs_allocator: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_allocator.c | 408 ++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_allocator.h | 30 +++ 2 files changed, 438 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_allocator.c create mode 100644 drivers/staging/yaffs2/yaffs_allocator.h
drivers/staging/yaffs2/yaffs_allocator.c new file +408 -0
@@ -0,0 +1,408 @@ +/* +* 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 <[email protected]> +* +* 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_allocator.h" +#include "yaffs_guts.h" +#include "yaffs_trace.h" +#include "yportenv.h" + +#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR + +void yaffs_deinit_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +void yaffs_init_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +yaffs_tnode_t *yaffs_alloc_raw_tnode (yaffs_dev_t *dev) +{ +return (yaffs_tnode_t *)YMALLOC (dev->tnode_size); +} + +void yaffs_free_raw_tnode (yaffs_dev_t *dev,yaffs_tnode_t *tn) +{ + dev = dev; +YFREE (tn); +} + +void yaffs_init_raw_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +void yaffs_deinit_raw_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +yaffs_obj_t *yaffs_alloc_raw_obj (yaffs_dev_t *dev) +{ + dev = dev; +return (yaffs_obj_t *)YMALLOC (sizeof (yaffs_obj_t)); +} + + +void yaffs_free_raw_obj (yaffs_dev_t *dev,yaffs_obj_t *obj) +{ + + dev = dev; +YFREE (obj); +} + +#else + +struct yaffs_tnode_list { +struct yaffs_tnode_list *next; +yaffs_tnode_t *tnodes; +}; + +typedef struct yaffs_tnode_list yaffs_tnodelist_t ; + +struct yaffs_obj_list_struct { +yaffs_obj_t *objects; +struct yaffs_obj_list_struct *next; +}; + +typedef struct yaffs_obj_list_struct yaffs_obj_list ; + + +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; +}; + +typedef struct yaffs_AllocatorStruct yaffs_Allocator ; + + +static void yaffs_deinit_raw_tnodes (yaffs_dev_t *dev) +{ + +yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; + +yaffs_tnodelist_t *tmp; + +if (!allocator){ +YBUG (); +return ; + } + +while (allocator->allocatedTnodeList) { + tmp = allocator->allocatedTnodeList->next; + +YFREE (allocator->allocatedTnodeList->tnodes); +YFREE (allocator->allocatedTnodeList); + allocator->allocatedTnodeList = tmp; + + } + + allocator->freeTnodes =NULL ; + allocator->nFreeTnodes =0 ; + allocator->n_tnodesCreated =0 ; +} + +static void yaffs_init_raw_tnodes (yaffs_dev_t *dev) +{ +yaffs_Allocator *allocator = dev->allocator; + +if (allocator){ + allocator->allocatedTnodeList =NULL ; + allocator->freeTnodes =NULL ; + allocator->nFreeTnodes =0 ; + allocator->n_tnodesCreated =0 ; + }else +YBUG (); +} + +static int yaffs_create_tnodes (yaffs_dev_t *dev,int n_tnodes) +{ +yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; +int i; +yaffs_tnode_t *newTnodes; +__u8 *mem; +yaffs_tnode_t *curr; +yaffs_tnode_t *next; +yaffs_tnodelist_t *tnl; + +if (!allocator){ +YBUG (); +return YAFFS_FAIL ; + } + +if (n_tnodes <1 ) +return YAFFS_OK ; + + +/* make these things */ + + newTnodes =YMALLOC (n_tnodes * dev->tnode_size); + mem = (__u8 *)newTnodes; + +if (!newTnodes) { +T (YAFFS_TRACE_ERROR , + (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->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; + + allocator->nFreeTnodes += n_tnodes; + allocator->n_tnodesCreated += 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)); +if (!tnl) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("yaffs: Could not add tnodes to management list" TENDSTR ))); +return YAFFS_FAIL ; + }else { + tnl->tnodes = newTnodes; + tnl->next = allocator->allocatedTnodeList; + allocator->allocatedTnodeList = tnl; + } + +T (YAFFS_TRACE_ALLOCATE , (TSTR ("yaffs: Tnodes added" TENDSTR ))); + +return YAFFS_OK ; +} + + +yaffs_tnode_t *yaffs_alloc_raw_tnode (yaffs_dev_t *dev) +{ +yaffs_Allocator *allocator = (yaffs_Allocator *)dev->allocator; +yaffs_tnode_t *tn =NULL ; + +if (!allocator){ +YBUG (); +return NULL ; + } + +/* If there are none left make more */ +if (!allocator->freeTnodes) +yaffs_create_tnodes (dev,YAFFS_ALLOCATION_NTNODES ); + +if (allocator->freeTnodes) { + tn = allocator->freeTnodes; + allocator->freeTnodes = allocator->freeTnodes->internal[0 ]; + allocator->nFreeTnodes--; + } + +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) +{ +yaffs_Allocator *allocator = dev->allocator; + +if (!allocator){ +YBUG (); +return ; + } + +if (tn) { + tn->internal[0 ] = allocator->freeTnodes; + allocator->freeTnodes = tn; + allocator->nFreeTnodes++; + } + dev->checkpoint_blocks_required =0 ;/* force recalculation*/ +} + + + +static void yaffs_init_raw_objs (yaffs_dev_t *dev) +{ +yaffs_Allocator *allocator = dev->allocator; + +if (allocator) { + allocator->allocated_list =NULL ; + allocator->freeObjects =NULL ; + allocator->nFreeObjects =0 ; + }else +YBUG (); +} + +static void yaffs_deinit_raw_objs (yaffs_dev_t *dev) +{ +yaffs_Allocator *allocator = dev->allocator; +yaffs_obj_list *tmp; + +if (!allocator){ +YBUG (); +return ; + } + +while (allocator->allocated_list) { + tmp = allocator->allocated_list->next; +YFREE (allocator->allocated_list->objects); +YFREE (allocator->allocated_list); + + allocator->allocated_list = tmp; + } + + allocator->freeObjects =NULL ; + allocator->nFreeObjects =0 ; + allocator->n_objCreated =0 ; +} + + +static int yaffs_create_free_objs (yaffs_dev_t *dev,int n_obj) +{ +yaffs_Allocator *allocator = dev->allocator; + +int i; +yaffs_obj_t *newObjects; +yaffs_obj_list *list; + +if (!allocator){ +YBUG (); +return YAFFS_FAIL ; + } + +if (n_obj <1 ) +return YAFFS_OK ; + +/* make these things */ + newObjects =YMALLOC (n_obj *sizeof (yaffs_obj_t)); + list =YMALLOC (sizeof (yaffs_obj_list)); + +if (!newObjects || !list) { +if (newObjects){ +YFREE (newObjects); + newObjects =NULL ; + } +if (list){ +YFREE (list); + list =NULL ; + } +T (YAFFS_TRACE_ALLOCATE , + (TSTR ("yaffs: Could not allocate more objects" TENDSTR ))); +return YAFFS_FAIL ; + } + +/* Hook them into the free list */ +for (i =0 ; i < n_obj -1 ; i++) { + newObjects[i].siblings.next = + (struct ylist_head *)(&newObjects[i +1 ]); + } + + newObjects[n_obj -1 ].siblings.next = (void *)allocator->freeObjects; + allocator->freeObjects = newObjects; + allocator->nFreeObjects += n_obj; + allocator->n_objCreated += 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; + +return YAFFS_OK ; +} + +yaffs_obj_t *yaffs_alloc_raw_obj (yaffs_dev_t *dev) +{ +yaffs_obj_t *obj =NULL ; +yaffs_Allocator *allocator = dev->allocator; + +if (!allocator) { +YBUG (); +return obj; + } + +/* If there are none left make more */ +if (!allocator->freeObjects) +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--; + } + +return obj; +} + + +void yaffs_free_raw_obj (yaffs_dev_t *dev,yaffs_obj_t *obj) +{ + +yaffs_Allocator *allocator = dev->allocator; + +if (!allocator) +YBUG (); +else { +/* Link into the free list. */ + obj->siblings.next = (struct ylist_head *)(allocator->freeObjects); + allocator->freeObjects = obj; + allocator->nFreeObjects++; + } +} + +void yaffs_deinit_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ +if (dev->allocator){ +yaffs_deinit_raw_tnodes (dev); +yaffs_deinit_raw_objs (dev); + +YFREE (dev->allocator); + dev->allocator=NULL ; + }else +YBUG (); +} + +void yaffs_init_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ +yaffs_Allocator *allocator; + +if (!dev->allocator){ + allocator =YMALLOC (sizeof (yaffs_Allocator)); +if (allocator){ + dev->allocator = allocator; +yaffs_init_raw_tnodes (dev); +yaffs_init_raw_objs (dev); + } + }else +YBUG (); +} + + +#endif
drivers/staging/yaffs2/yaffs_allocator.h new file +30 -0
@@ -0,0 +1,30 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_ALLOCATOR_H__ +#define __YAFFS_ALLOCATOR_H__ + +#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); + +yaffs_tnode_t *yaffs_alloc_raw_tnode (yaffs_dev_t *dev); +void yaffs_free_raw_tnode (yaffs_dev_t *dev,yaffs_tnode_t *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); + +#endif
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 05/29] Staging: yaffs2: yaffs_allocator: Add files
Quoted 48 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_allocator.c | 408 ++++++++++++++++++++++++++++++drivers/staging/yaffs2/yaffs_allocator.h| 30 +++2 files changed, 438 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_allocator.ccreate mode 100644drivers/staging/yaffs2/yaffs_allocator.hdrivers/staging/yaffs2/yaffs_allocator.c new file +32
-0@@ -0,0 +1,408 @@ +/* +* 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 <[email protected]> +* +* 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_allocator.h" +#include "yaffs_guts.h" +#include "yaffs_trace.h" +#include "yportenv.h" + +#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR + +void yaffs_deinit_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +void yaffs_init_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} +
drivers/staging/yaffs2/yaffs_allocator.c line 42
Quoted 10 lines
drivers/staging/yaffs2/yaffs_allocator.c new file +10
-0+yaffs_tnode_t *yaffs_alloc_raw_tnode (yaffs_dev_t *dev) +{ + return (yaffs_tnode_t *)YMALLOC(dev->tnode_size); +} + +void yaffs_free_raw_tnode (yaffs_dev_t *dev,yaffs_tnode_t *tn) +{ + dev = dev; + YFREE(tn); +}
So you have your own dynamic memory allocator? What's wrong with kmalloc()? --
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 05/29] Staging: yaffs2: yaffs_allocator: Add files
Quoted 54 lines · On Tuesday 02 November 2010 07:58:49 Pekka Enberg wrote:
Quoted 53 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_allocator.c | 408 ++++++++++++++++++++++++++++++drivers/staging/yaffs2/yaffs_allocator.h| 30 +++2 files changed, 438 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_allocator.ccreate mode 100644drivers/staging/yaffs2/yaffs_allocator.h(quoted diff) +0
-0
b/drivers/staging/yaffs2/yaffs_allocator.cnew file mode 100644 index 0000000..024ee2adrivers/staging/yaffs2/yaffs_allocator.c new file +2
-0@@ -0,0 +1,408 @@ +/* +* 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 <[email protected]>
+ *
+ * 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.
+ */drivers/staging/yaffs2/yaffs_allocator.c new file +24
-0+ + + +#include "yaffs_allocator.h" +#include "yaffs_guts.h" +#include "yaffs_trace.h" +#include "yportenv.h" + +#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR + +void yaffs_deinit_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +void yaffs_init_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +yaffs_tnode_t *yaffs_alloc_raw_tnode (yaffs_dev_t *dev) +{ + return (yaffs_tnode_t *)YMALLOC(dev->tnode_size); +}
Quoted 8 lines
drivers/staging/yaffs2/yaffs_allocator.c line 42
Quoted 6 lines
drivers/staging/yaffs2/yaffs_allocator.c new file +6
-0+ +void yaffs_free_raw_tnode (yaffs_dev_t *dev,yaffs_tnode_t *tn) +{ + dev = dev; + YFREE(tn); +}So you have your own dynamic memory allocator? What's wrong with
kmalloc()?
No. YMALLOC() wraps kmalloc() to keep the code portable.
This code does a home-grown slab allocator. The reason for doing this is that Linux slab does not allow slab caches to be destroyed while objects exist.
While that might sound like a dangerous practice, it does mean that when yaffs unmounts it can drop all the data structures without having to walk all the trees freeing the objects.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 05/29] Staging: yaffs2: yaffs_allocator: Add files
Quoted 64 lines · Charles Manning
Quoted 54 lines · On Tuesday 02 November 2010 07:58:49 Pekka Enberg wrote:
Quoted 53 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_allocator.c | 408 ++++++++++++++++++++++++++++++drivers/staging/yaffs2/yaffs_allocator.h| 30 +++2 files changed, 438 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_allocator.ccreate mode 100644drivers/staging/yaffs2/yaffs_allocator.h(quoted diff) +0
-0
b/drivers/staging/yaffs2/yaffs_allocator.cnew file mode 100644 index 0000000..024ee2adrivers/staging/yaffs2/yaffs_allocator.c new file +2
-0@@ -0,0 +1,408 @@ +/* +* 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 <[email protected]>
+ *
+ * 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.
+ */drivers/staging/yaffs2/yaffs_allocator.c new file +24
-0+ + + +#include "yaffs_allocator.h" +#include "yaffs_guts.h" +#include "yaffs_trace.h" +#include "yportenv.h" + +#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR + +void yaffs_deinit_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +void yaffs_init_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +yaffs_tnode_t *yaffs_alloc_raw_tnode (yaffs_dev_t *dev) +{ + return (yaffs_tnode_t *)YMALLOC(dev->tnode_size); +}Quoted 8 lines
drivers/staging/yaffs2/yaffs_allocator.c line 42
Quoted 6 lines
drivers/staging/yaffs2/yaffs_allocator.c new file +6
-0+ +void yaffs_free_raw_tnode (yaffs_dev_t *dev,yaffs_tnode_t *tn) +{ + dev = dev; + YFREE(tn); +}So you have your own dynamic memory allocator? What's wrong with
kmalloc()?
Quoted 8 lines
No.
YMALLOC()wrapskmalloc()to keep the code portable.This code does a home-grown slab allocator. The reason for doing this is that Linux slab does not allow slab caches to be destroyed while objects exist.
While that might sound like a dangerous practice, it does mean that when yaffs unmounts it can drop all the data structures without having to walk all the trees freeing the objects.
Either way, your home-grown slab allocator is not going to be merged this way. You should be using kmem_cache_alloc() and propose proper patches on top of mm/sl?b.c.
Re: [PATCH 05/29] Staging: yaffs2: yaffs_allocator: Add files
Quoted 70 lines · Pekka Enberg
Quoted 69 lines · Charles Manning
Quoted 54 lines · On Tuesday 02 November 2010 07:58:49 Pekka Enberg wrote:
Quoted 53 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_allocator.c | 408 ++++++++++++++++++++++++++++++drivers/staging/yaffs2/yaffs_allocator.h| 30 +++2 files changed, 438 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_allocator.ccreate mode 100644drivers/staging/yaffs2/yaffs_allocator.h(quoted diff) +0
-0
b/drivers/staging/yaffs2/yaffs_allocator.cnew file mode 100644 index 0000000..024ee2adrivers/staging/yaffs2/yaffs_allocator.c new file +2
-0@@ -0,0 +1,408 @@ +/* +* 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 <[email protected]>
+ *
+ * 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.
+ */drivers/staging/yaffs2/yaffs_allocator.c new file +24
-0+ + + +#include "yaffs_allocator.h" +#include "yaffs_guts.h" +#include "yaffs_trace.h" +#include "yportenv.h" + +#ifdef CONFIG_YAFFS_YMALLOC_ALLOCATOR + +void yaffs_deinit_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +void yaffs_init_raw_tnodes_and_objs (yaffs_dev_t *dev) +{ + dev = dev; +} + +yaffs_tnode_t *yaffs_alloc_raw_tnode (yaffs_dev_t *dev) +{ + return (yaffs_tnode_t *)YMALLOC(dev->tnode_size); +}Quoted 8 lines
drivers/staging/yaffs2/yaffs_allocator.c line 42
Quoted 6 lines
drivers/staging/yaffs2/yaffs_allocator.c new file +6
-0+ +void yaffs_free_raw_tnode (yaffs_dev_t *dev,yaffs_tnode_t *tn) +{ + dev = dev; + YFREE(tn); +}So you have your own dynamic memory allocator? What's wrong with
kmalloc()?No.
YMALLOC()wrapskmalloc()to keep the code portable.This code does a home-grown slab allocator. The reason for doing this is that Linux slab does not allow slab caches to be destroyed while objects exist.
Quoted 7 lines
Quoted 3 lines
While that might sound like a dangerous practice, it does mean that when yaffs unmounts it can drop all the data structures without having to walk all the trees freeing the objects.
Either way, your home-grown slab allocator is not going to be merged this way. You should be using
kmem_cache_alloc()and propose proper patches on top of mm/sl?b.c.
Btw, just to clarify: Greg might not mind taking it in as-is but it'll never be promoted to mainline proper this way.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 6/29 Staging: yaffs2: yaffs_bitmap: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_bitmap.c | 105 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_bitmap.h | 33 ++++++++++ 2 files changed, 138 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_bitmap.c create mode 100644 drivers/staging/yaffs2/yaffs_bitmap.h
drivers/staging/yaffs2/yaffs_bitmap.c new file +105 -0
@@ -0,0 +1,105 @@ +/* +* 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 <[email protected]> +* +* 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_bitmap.h" +#include "yaffs_trace.h" +/* +* Chunk bitmap manipulations +*/ + +static Y_INLINE __u8 *yaffs_block_bits(yaffs_dev_t *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)); +YBUG (); + } +return dev->chunk_bits + + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); +} + +void yaffs_verify_chunk_bit_id (yaffs_dev_t *dev,int blk,int chunk) +{ +if (blk < dev->internal_start_block || blk > dev->internal_end_block || + chunk <0 || chunk >= dev->param.chunks_per_block) { +T (YAFFS_TRACE_ERROR , + (TSTR ("**>> yaffs: Chunk Id (%d:%d) invalid" TENDSTR ), + blk, chunk)); +YBUG (); + } +} + +void yaffs_clear_chunk_bits (yaffs_dev_t *dev,int 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) +{ +__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) +{ +__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) +{ +__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) +{ +__u8 *blk_bits =yaffs_block_bits (dev, blk); +int i; +for (i =0 ; i < dev->chunk_bit_stride; i++) { +if (*blk_bits) +return 1 ; + blk_bits++; + } +return 0 ; +} + +int yaffs_count_chunk_bits (yaffs_dev_t *dev,int 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; +while (x) { +if (x &1 ) + n++; + x >>=1 ; + } + + blk_bits++; + } +return n; +} +
drivers/staging/yaffs2/yaffs_bitmap.h new file +33 -0
@@ -0,0 +1,33 @@ +/* +* 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 <[email protected]> +* +* 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. +*/ + +/* +* Chunk bitmap manipulations +*/ + +#ifndef __YAFFS_BITMAP_H__ +#define __YAFFS_BITMAP_H__ + +#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); + +#endif
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 06/29] Staging: yaffs2: yaffs_bitmap: Add files
Quoted 36 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_bitmap.c | 105 +++++++++++++++++++++++++++++++++drivers/staging/yaffs2/yaffs_bitmap.h| 33 ++++++++++2 files changed, 138 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_bitmap.ccreate mode 100644drivers/staging/yaffs2/yaffs_bitmap.hdrivers/staging/yaffs2/yaffs_bitmap.c new file +20
-0@@ -0,0 +1,105 @@ +/* +* 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 <[email protected]> +* +* 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_bitmap.h" +#include "yaffs_trace.h" +/* +* Chunk bitmap manipulations +*/ + +static Y_INLINE __u8 *yaffs_block_bits(yaffs_dev_t *dev, int blk)
drivers/staging/yaffs2/yaffs_bitmap.c line 30
Quoted 10 lines
drivers/staging/yaffs2/yaffs_bitmap.c new file +10
-0+{ + 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)); + YBUG(); + } + return dev->chunk_bits + + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); +}
We have <linux/bitmap.h>. You should probably use it.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 7/29 Staging: yaffs2: yaffs_checkptrw: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_checkptrw.c | 400 ++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_checkptrw.h | 34 +++ 2 files changed, 434 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_checkptrw.c create mode 100644 drivers/staging/yaffs2/yaffs_checkptrw.h
drivers/staging/yaffs2/yaffs_checkptrw.c new file +400 -0
@@ -0,0 +1,400 @@ +/* +* 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 <[email protected]> +* +* 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_checkptrw.h" +#include "yaffs_getblockinfo.h" + +static int yaffs2_checkpt_space_ok (yaffs_dev_t *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)); + +return (blocks_avail <=0 ) ?0 :1 ; +} + + +static int yaffs_checkpt_erase (yaffs_dev_t *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)); + +for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { +yaffs_block_info_t *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)); + + dev->n_erasures++; + +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; + }else { + dev->param.bad_block_fn (dev, i); + bi->block_state =YAFFS_BLOCK_STATE_DEAD ; + } + } + } + + dev->blocks_in_checkpt =0 ; + +return 1 ; +} + + +static void yaffs2_checkpt_find_erased_block (yaffs_dev_t *dev) +{ +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)); + +if (dev->checkpt_next_block >=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); +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)); +return ; + } + } + } +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) +{ +int i; +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)); + +if (dev->blocks_in_checkpt < dev->checkpt_max_blocks) +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)); + +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->blocks_in_checkpt++; +T (YAFFS_TRACE_CHECKPOINT , (TSTR ("found checkpt block %d" TENDSTR ), i)); +return ; + } + } + +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) +{ + + + 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) +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); +if (!dev->checkpt_buffer) +return 0 ; + + + dev->checkpt_page_seq =0 ; + dev->checkpt_byte_count =0 ; + dev->checkpt_sum =0 ; + dev->checkpt_xor =0 ; + dev->checkpt_cur_block =-1 ; + dev->checkpt_cur_chunk =-1 ; + dev->checkpt_next_block = dev->internal_start_block; + +/* Erase all the blocks in the checkpoint area */ +if (writing) { +memset (dev->checkpt_buffer,0 , dev->data_bytes_per_chunk); + dev->checkpt_byte_offs =0 ; +return yaffs_checkpt_erase (dev); + }else { +int i; +/* Set to a value that will kick off a read */ + dev->checkpt_byte_offs = dev->data_bytes_per_chunk; +/* 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) +return 0 ; + +for (i =0 ; i < dev->checkpt_max_blocks; i++) + dev->checkpt_block_list[i] =-1 ; + } + +return 1 ; +} + +int yaffs2_get_checkpt_sum (yaffs_dev_t *dev,__u32 *sum) +{ +__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) +{ +int chunk; +int realigned_chunk; + +yaffs_ext_tags tags; + +if (dev->checkpt_cur_block <0 ) { +yaffs2_checkpt_find_erased_block (dev); + dev->checkpt_cur_chunk =0 ; + } + +if (dev->checkpt_cur_block <0 ) +return 0 ; + + tags.is_deleted =0 ; + 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.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); + 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; + + +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_byte_offs =0 ; + dev->checkpt_page_seq++; + dev->checkpt_cur_chunk++; +if (dev->checkpt_cur_chunk >= dev->param.chunks_per_block) { + dev->checkpt_cur_chunk =0 ; + dev->checkpt_cur_block =-1 ; + } +memset (dev->checkpt_buffer,0 , dev->data_bytes_per_chunk); + +return 1 ; +} + + +int yaffs2_checkpt_wr (yaffs_dev_t *dev,const void *data,int n_bytes) +{ +int i =0 ; +int ok =1 ; + + +__u8 * data_bytes = (__u8 *)data; + + + +if (!dev->checkpt_buffer) +return 0 ; + +if (!dev->checkpt_open_write) +return -1 ; + +while (i < n_bytes && ok) { + dev->checkpt_buffer[dev->checkpt_byte_offs] = *data_bytes; + dev->checkpt_sum += *data_bytes; + dev->checkpt_xor ^= *data_bytes; + + dev->checkpt_byte_offs++; + i++; + data_bytes++; + dev->checkpt_byte_count++; + + +if (dev->checkpt_byte_offs <0 || + 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 i =0 ; +int ok =1 ; +yaffs_ext_tags tags; + + +int chunk; +int realigned_chunk; + +__u8 *data_bytes = (__u8 *)data; + +if (!dev->checkpt_buffer) +return 0 ; + +if (dev->checkpt_open_write) +return -1 ; + +while (i < n_bytes && ok) { + + +if (dev->checkpt_byte_offs <0 || + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { + +if (dev->checkpt_cur_block <0 ) { +yaffs2_checkpt_find_block (dev); + dev->checkpt_cur_chunk =0 ; + } + +if (dev->checkpt_cur_block <0 ) + ok =0 ; +else { + chunk = dev->checkpt_cur_block * + 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 ) + 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) + dev->checkpt_cur_block =-1 ; + } + } + +if (ok) { + *data_bytes = dev->checkpt_buffer[dev->checkpt_byte_offs]; + dev->checkpt_sum += *data_bytes; + dev->checkpt_xor ^= *data_bytes; + dev->checkpt_byte_offs++; + i++; + data_bytes++; + dev->checkpt_byte_count++; + } + } + +return i; +} + +int yaffs_checkpt_close (yaffs_dev_t *dev) +{ + +if (dev->checkpt_open_write) { +if (dev->checkpt_byte_offs !=0 ) +yaffs2_checkpt_flush_buffer (dev); + }else if (dev->checkpt_block_list){ +int 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) + bi =yaffs_get_block_info (dev, blk); +if (bi && bi->block_state ==YAFFS_BLOCK_STATE_EMPTY ) + bi->block_state =YAFFS_BLOCK_STATE_CHECKPOINT ; +else { +/* Todo this looks odd... */ + } + } +YFREE (dev->checkpt_block_list); + dev->checkpt_block_list =NULL ; + } + + 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)); + +if (dev->checkpt_buffer) { +/* free the buffer */ +YFREE (dev->checkpt_buffer); + dev->checkpt_buffer =NULL ; +return 1 ; + }else +return 0 ; +} + +int yaffs2_checkpt_invalidate_stream (yaffs_dev_t *dev) +{ +/* Erase the checkpoint data */ + +T (YAFFS_TRACE_CHECKPOINT , (TSTR ("checkpoint invalidate of %d blocks" TENDSTR ), + dev->blocks_in_checkpt)); + +return yaffs_checkpt_erase (dev); +} + + +
drivers/staging/yaffs2/yaffs_checkptrw.h new file +34 -0
@@ -0,0 +1,34 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_CHECKPTRW_H__ +#define __YAFFS_CHECKPTRW_H__ + +#include "yaffs_guts.h" + +int yaffs2_checkpt_open (yaffs_dev_t *dev,int writing); + +int yaffs2_checkpt_wr (yaffs_dev_t *dev,const void *data,int n_bytes); + +int yaffs2_checkpt_rd (yaffs_dev_t *dev,void *data,int n_bytes); + +int yaffs2_get_checkpt_sum (yaffs_dev_t *dev,__u32 *sum); + +int yaffs_checkpt_close (yaffs_dev_t *dev); + +int yaffs2_checkpt_invalidate_stream (yaffs_dev_t *dev); + + +#endif
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 07/29] Staging: yaffs2: yaffs_checkptrw: Add files
Quoted 15 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>--- drivers/staging/yaffs2/yaffs_checkptrw.c | 400 ++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_checkptrw.h | 34 +++ 2 files changed, 434 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_checkptrw.c create mode 100644 drivers/staging/yaffs2/yaffs_checkptrw.hdrivers/staging/yaffs2/yaffs_checkptrw.c new file +0
-0
[snip]
drivers/staging/yaffs2/yaffs_checkptrw.c line 73
Quoted 12 lines
drivers/staging/yaffs2/yaffs_checkptrw.c new file +12
-0+static void yaffs2_checkpt_find_erased_block (yaffs_dev_t *dev) +{ +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)); + +if (dev->checkpt_next_block >=0 && + dev->checkpt_next_block <= dev->internal_end_block && + blocks_avail >0 ) { +
Ok, perhaps I've been writing C++ apps in userspace too much, but on first impulse I'd say that the 'i' variable should be declared here in this scope where it's first used and not in global function scope.
Quoted 1 line
drivers/staging/yaffs2/yaffs_checkptrw.c new file +1
-0+for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) {
[snip]
drivers/staging/yaffs2/yaffs_checkptrw.c line 98
Quoted 9 lines
drivers/staging/yaffs2/yaffs_checkptrw.c new file +9
-0+static void yaffs2_checkpt_find_block (yaffs_dev_t *dev) +{ +int i; +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)); + +if (dev->blocks_in_checkpt < dev->checkpt_max_blocks)
same here.
Quoted 1 line
drivers/staging/yaffs2/yaffs_checkptrw.c new file +1
-0+for (i = dev->checkpt_next_block; i <= dev->internal_end_block; i++) {
[snip]
drivers/staging/yaffs2/yaffs_checkptrw.c line 129
Quoted 4 lines
drivers/staging/yaffs2/yaffs_checkptrw.c new file +4
-0+int yaffs2_checkpt_open (yaffs_dev_t *dev,int writing) +{ + +
Small thing, but I've seen this a lot in these patches - double blank lines (or more) where either a single one or zero would do just as well (or actually better).
It's a small thing, but the number of (relevant) code lines visible on the screen at once actually matters. Sure, a blank line between blocks often makes sense in order to visually seperate one block of code from another, but two (or more) lines often don't serve a purpose except prevent more relevant stuff to being visible - especially in cases like this where it's at the start of a function, I really don't see the point.
drivers/staging/yaffs2/yaffs_checkptrw.c line 186
Quoted 7 lines
drivers/staging/yaffs2/yaffs_checkptrw.c new file +7
-0+int yaffs2_get_checkpt_sum (yaffs_dev_t *dev,__u32 *sum) +{ +__u32 composite_sum; + composite_sum = (dev->checkpt_sum <<8 ) | (dev->checkpt_xor &0xFF ); + *sum = composite_sum; +return 1 ; +}
Why not
int yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum)
{
*sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
return 1;
}???
Signature · 3 lines
Jesper Juhl <[email protected]> http://www.chaosbits.net/ Plain text mails only, please http://www.expita.com/nomime.html Don't top-post http://www.catb.org/~esr/jargon/html/T/top-post.html
Re: [PATCH 07/29] Staging: yaffs2: yaffs_checkptrw: Add files
Quoted 2 lines · Jesper Juhl
On Mon, 1 Nov 2010, Tracey Dent wrote:
[snip]
Quoted 11 lines
drivers/staging/yaffs2/yaffs_checkptrw.c line 186
Quoted 8 lines
drivers/staging/yaffs2/yaffs_checkptrw.c new file +7
-0+int yaffs2_get_checkpt_sum (yaffs_dev_t *dev,__u32 *sum) +{ +__u32 composite_sum; + composite_sum = (dev->checkpt_sum <<8 ) | (dev->checkpt_xor &0xFF ); + *sum = composite_sum; +return 1 ; +}Why not
Quoted 6 lines
int
yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum){ *sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF); return 1; }
And by the way, why is this function not returning 'void' so it just becomes:
void yaffs2_get_checkpt_sum(yaffs_dev_t *dev, __u32 *sum)
{
*sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xFF);
}Since it's always returning '1' I fail to see the point of the 'int' return value.
Signature · 3 lines
Jesper Juhl <[email protected]> http://www.chaosbits.net/ Plain text mails only, please http://www.expita.com/nomime.html Don't top-post http://www.catb.org/~esr/jargon/html/T/top-post.html
PATCH 8/29 Staging: yaffs2: yaffs_ecc: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_ecc.c | 323 ++++++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_ecc.h | 44 +++++ 2 files changed, 367 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_ecc.c create mode 100644 drivers/staging/yaffs2/yaffs_ecc.h
drivers/staging/yaffs2/yaffs_ecc.c new file +323 -0
@@ -0,0 +1,323 @@ +/* +* 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 <[email protected]> +* +* 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 code implements the ECC algorithm used in SmartMedia. +* +* The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. +* The two unused bit are set to 1. +* The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC +* blocks are used on a 512-byte NAND page. +* +*/ + +/* Table generated by gen-ecc.c +* Using a table means we do not have to calculate p1..p4 and p1'..p4' +* for each byte of data. These are instead provided in a table in bits7..2. +* Bit 0 of each entry indicates whether the entry has an odd or even parity, and therefore +* this bytes influence on the line parity. +*/ + +#include "yportenv.h" + +#include "yaffs_ecc.h" + +static const unsigned char column_parity_table[] = { +0x00 ,0x55 ,0x59 ,0x0c ,0x65 ,0x30 ,0x3c ,0x69 , +0x69 ,0x3c ,0x30 ,0x65 ,0x0c ,0x59 ,0x55 ,0x00 , +0x95 ,0xc0 ,0xcc ,0x99 ,0xf0 ,0xa5 ,0xa9 ,0xfc , +0xfc ,0xa9 ,0xa5 ,0xf0 ,0x99 ,0xcc ,0xc0 ,0x95 , +0x99 ,0xcc ,0xc0 ,0x95 ,0xfc ,0xa9 ,0xa5 ,0xf0 , +0xf0 ,0xa5 ,0xa9 ,0xfc ,0x95 ,0xc0 ,0xcc ,0x99 , +0x0c ,0x59 ,0x55 ,0x00 ,0x69 ,0x3c ,0x30 ,0x65 , +0x65 ,0x30 ,0x3c ,0x69 ,0x00 ,0x55 ,0x59 ,0x0c , +0xa5 ,0xf0 ,0xfc ,0xa9 ,0xc0 ,0x95 ,0x99 ,0xcc , +0xcc ,0x99 ,0x95 ,0xc0 ,0xa9 ,0xfc ,0xf0 ,0xa5 , +0x30 ,0x65 ,0x69 ,0x3c ,0x55 ,0x00 ,0x0c ,0x59 , +0x59 ,0x0c ,0x00 ,0x55 ,0x3c ,0x69 ,0x65 ,0x30 , +0x3c ,0x69 ,0x65 ,0x30 ,0x59 ,0x0c ,0x00 ,0x55 , +0x55 ,0x00 ,0x0c ,0x59 ,0x30 ,0x65 ,0x69 ,0x3c , +0xa9 ,0xfc ,0xf0 ,0xa5 ,0xcc ,0x99 ,0x95 ,0xc0 , +0xc0 ,0x95 ,0x99 ,0xcc ,0xa5 ,0xf0 ,0xfc ,0xa9 , +0xa9 ,0xfc ,0xf0 ,0xa5 ,0xcc ,0x99 ,0x95 ,0xc0 , +0xc0 ,0x95 ,0x99 ,0xcc ,0xa5 ,0xf0 ,0xfc ,0xa9 , +0x3c ,0x69 ,0x65 ,0x30 ,0x59 ,0x0c ,0x00 ,0x55 , +0x55 ,0x00 ,0x0c ,0x59 ,0x30 ,0x65 ,0x69 ,0x3c , +0x30 ,0x65 ,0x69 ,0x3c ,0x55 ,0x00 ,0x0c ,0x59 , +0x59 ,0x0c ,0x00 ,0x55 ,0x3c ,0x69 ,0x65 ,0x30 , +0xa5 ,0xf0 ,0xfc ,0xa9 ,0xc0 ,0x95 ,0x99 ,0xcc , +0xcc ,0x99 ,0x95 ,0xc0 ,0xa9 ,0xfc ,0xf0 ,0xa5 , +0x0c ,0x59 ,0x55 ,0x00 ,0x69 ,0x3c ,0x30 ,0x65 , +0x65 ,0x30 ,0x3c ,0x69 ,0x00 ,0x55 ,0x59 ,0x0c , +0x99 ,0xcc ,0xc0 ,0x95 ,0xfc ,0xa9 ,0xa5 ,0xf0 , +0xf0 ,0xa5 ,0xa9 ,0xfc ,0x95 ,0xc0 ,0xcc ,0x99 , +0x95 ,0xc0 ,0xcc ,0x99 ,0xf0 ,0xa5 ,0xa9 ,0xfc , +0xfc ,0xa9 ,0xa5 ,0xf0 ,0x99 ,0xcc ,0xc0 ,0x95 , +0x00 ,0x55 ,0x59 ,0x0c ,0x65 ,0x30 ,0x3c ,0x69 , +0x69 ,0x3c ,0x30 ,0x65 ,0x0c ,0x59 ,0x55 ,0x00 , +}; + +/* Count the bits in an unsigned char or a U32 */ + +static int yaffs_count_bits (unsigned char x) +{ +int r =0 ; +while (x) { +if (x &1 ) + r++; + x >>=1 ; + } +return r; +} + +static int yaffs_count_bits32 (unsigned x) +{ +int r =0 ; +while (x) { +if (x &1 ) + r++; + x >>=1 ; + } +return r; +} + +/* Calculate the ECC for a 256-byte block of data */ +void yaffs_ecc_cacl (const unsigned char *data,unsigned char *ecc) +{ +unsigned int i; + +unsigned char col_parity =0 ; +unsigned char line_parity =0 ; +unsigned char line_parity_prime =0 ; +unsigned char t; +unsigned char b; + +for (i =0 ; i <256 ; i++) { + b = column_parity_table[*data++]; + col_parity ^= b; + +if (b &0x01 ) {/* odd number of bits in the byte */ + line_parity ^= i; + line_parity_prime ^= ~i; + } + } + + ecc[2 ] = (~col_parity) |0x03 ; + + t =0 ; +if (line_parity &0x80 ) + t |=0x80 ; +if (line_parity_prime &0x80 ) + t |=0x40 ; +if (line_parity &0x40 ) + t |=0x20 ; +if (line_parity_prime &0x40 ) + t |=0x10 ; +if (line_parity &0x20 ) + t |=0x08 ; +if (line_parity_prime &0x20 ) + t |=0x04 ; +if (line_parity &0x10 ) + t |=0x02 ; +if (line_parity_prime &0x10 ) + t |=0x01 ; + ecc[1 ] = ~t; + + t =0 ; +if (line_parity &0x08 ) + t |=0x80 ; +if (line_parity_prime &0x08 ) + t |=0x40 ; +if (line_parity &0x04 ) + t |=0x20 ; +if (line_parity_prime &0x04 ) + t |=0x10 ; +if (line_parity &0x02 ) + t |=0x08 ; +if (line_parity_prime &0x02 ) + t |=0x04 ; +if (line_parity &0x01 ) + t |=0x02 ; +if (line_parity_prime &0x01 ) + t |=0x01 ; + ecc[0 ] = ~t; + +#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER +/* Swap the bytes into the wrong order */ + t = ecc[0 ]; + ecc[0 ] = ecc[1 ]; + ecc[1 ] = t; +#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) +{ +unsigned char d0, d1, d2;/* deltas */ + + d0 = read_ecc[0 ] ^ test_ecc[0 ]; + d1 = read_ecc[1 ] ^ test_ecc[1 ]; + d2 = read_ecc[2 ] ^ test_ecc[2 ]; + +if ((d0 | d1 | d2) ==0 ) +return 0 ;/* no error */ + +if (((d0 ^ (d0 >>1 )) &0x55 ) ==0x55 && + ((d1 ^ (d1 >>1 )) &0x55 ) ==0x55 && + ((d2 ^ (d2 >>1 )) &0x54 ) ==0x54 ) { +/* Single bit (recoverable) error in data */ + +unsigned byte; +unsigned bit; + +#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER +/* swap the bytes to correct for the wrong order */ +unsigned char t; + + t = d0; + d0 = d1; + d1 = t; +#endif + + bit = byte =0 ; + +if (d1 &0x80 ) + byte |=0x80 ; +if (d1 &0x20 ) + byte |=0x40 ; +if (d1 &0x08 ) + byte |=0x20 ; +if (d1 &0x02 ) + byte |=0x10 ; +if (d0 &0x80 ) + byte |=0x08 ; +if (d0 &0x20 ) + byte |=0x04 ; +if (d0 &0x08 ) + byte |=0x02 ; +if (d0 &0x02 ) + byte |=0x01 ; + +if (d2 &0x80 ) + bit |=0x04 ; +if (d2 &0x20 ) + bit |=0x02 ; +if (d2 &0x08 ) + bit |=0x01 ; + + data[byte] ^= (1 << bit); + +return 1 ;/* Corrected the error */ + } + +if ((yaffs_count_bits (d0) + +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 */ + } + +/* Unrecoverable error */ + +return -1 ; + +} + + +/* +* 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) +{ +unsigned int i; + +unsigned char col_parity =0 ; +unsigned line_parity =0 ; +unsigned line_parity_prime =0 ; +unsigned char b; + +for (i =0 ; i < n_bytes; i++) { + b = column_parity_table[*data++]; + col_parity ^= b; + +if (b &0x01 ) { +/* odd number of bits in the byte */ + line_parity ^= i; + line_parity_prime ^= ~i; + } + + } + + ecc_other->col_parity = (col_parity >>2 ) &0x3f ; + ecc_other->line_parity = line_parity; + ecc_other->line_parity_prime = line_parity_prime; +} + +int yaffs_ecc_correct_other (unsigned char *data,unsigned n_bytes, +yaffs_ecc_other *read_ecc, +const yaffs_ecc_other *test_ecc) +{ +unsigned char delta_col;/* column parity delta */ +unsigned delta_line;/* line parity delta */ +unsigned delta_line_prime;/* line parity delta */ +unsigned bit; + + 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; + +if ((delta_col | delta_line | delta_line_prime) ==0 ) +return 0 ;/* no error */ + +if (delta_line == ~delta_line_prime && + (((delta_col ^ (delta_col >>1 )) &0x15 ) ==0x15 )) { +/* Single bit (recoverable) error in data */ + + bit =0 ; + +if (delta_col &0x20 ) + bit |=0x04 ; +if (delta_col &0x08 ) + bit |=0x02 ; +if (delta_col &0x02 ) + bit |=0x01 ; + +if (delta_line >= n_bytes) +return -1 ; + + data[delta_line] ^= (1 << bit); + +return 1 ;/* corrected */ + } + +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 */ + } + +/* Unrecoverable error */ + +return -1 ; +}
drivers/staging/yaffs2/yaffs_ecc.h new file +44 -0
44 lines not on this page · raw message
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 08/29] Staging: yaffs2: yaffs_ecc: Add files
Quoted 24 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_ecc.c | 323 ++++++++++++++++++++++++++++++++++++drivers/staging/yaffs2/yaffs_ecc.h| 44 +++++2 files changed, 367 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_ecc.ccreate mode 100644drivers/staging/yaffs2/yaffs_ecc.hdrivers/staging/yaffs2/yaffs_ecc.c new file +14
-0+ +/* Count the bits in an unsigned char or a U32 */ + +static int yaffs_count_bits (unsigned char x) +{ + int r = 0; + while (x) { + if (x & 1) + r++; + x >>= 1; + } + return r; +} +
drivers/staging/yaffs2/yaffs_ecc.c line 92
Quoted 10 lines
drivers/staging/yaffs2/yaffs_ecc.c new file +10
-0+static int yaffs_count_bits32 (unsigned x) +{ + int r = 0; + while (x) { + if (x & 1) + r++; + x >>= 1; + } + return r; +}
Looks like bitmap_weight() to me.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 08/29] Staging: yaffs2: yaffs_ecc: Add files
In reply to Tracey DentQuoted 7 lines · Tracey Dent
drivers/staging/yaffs2/yaffs_ecc.c new file +7
-0+/* +* This code implements the ECC algorithm used in SmartMedia. +* +* The ECC comprises 22 bits of parity information and is stuffed into 3 bytes. +* The two unused bit are set to 1. +* The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC +* blocks are used on a 512-byte NAND page.
drivers/staging/yaffs2/yaffs_ecc.c line 30
Quoted 10 lines
drivers/staging/yaffs2/yaffs_ecc.c new file +10
-0+* +*/ + +/* Table generated by gen-ecc.c +* Using a table means we do not have to calculate p1..p4 and p1'..p4' +* for each byte of data. These are instead provided in a table in bits7..2. +* Bit 0 of each entry indicates whether the entry has an odd or even parity, and therefore +* this bytes influence on the line parity. +*/ +
This all looks pretty generic. Have you considered just adding gen-ecc to lib/, tying it in to hostprogs, and generating the tables during build (see the crc32 code for reference)?
The rest of this would probably also be better off living in lib/ and simply being selected by the YAFFS code as necessary.
drivers/staging/yaffs2/yaffs_ecc.c
Quoted 4 lines
drivers/staging/yaffs2/yaffs_ecc.c new file +4
-0+/* Calculate the ECC for a 256-byte block of data */ +void yaffs_ecc_cacl(const unsigned char *data, unsigned char *ecc) +void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, + yaffs_ecc_other *ecc_other)
Is there some reason for this naming inconistency?
PATCH 9/29 Staging: yaffs2: yaffs_getblockinfo.h: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_getblockinfo.h | 35 +++++++++++++++++++++++++++ 1 files changed, 35 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_getblockinfo.h
drivers/staging/yaffs2/yaffs_getblockinfo.h new file +35 -0
@@ -0,0 +1,35 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_GETBLOCKINFO_H__ +#define __YAFFS_GETBLOCKINFO_H__ + +#include "yaffs_guts.h" +#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) +{ +if (blk < dev->internal_start_block || blk > dev->internal_end_block) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>> yaffs: get_block_info block %d is not valid" TENDSTR ), + blk)); +YBUG (); + } +return &dev->block_info[blk - dev->internal_start_block]; +} + +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 10/29 Staging: yaffs2: yaffs_guts: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_guts.c | 5544 +++++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_guts.h | 969 ++++++ 2 files changed, 6513 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_guts.c create mode 100644 drivers/staging/yaffs2/yaffs_guts.h
drivers/staging/yaffs2/yaffs_guts.c new file +5544 -0
@@ -0,0 +1,5544 @@ +/* +* 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 <[email protected]> +* +* 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 "yportenv.h" +#include "yaffs_trace.h" + +#include "yaffs_guts.h" +#include "yaffs_tagsvalidity.h" +#include "yaffs_getblockinfo.h" + +#include "yaffs_tagscompat.h" + +#include "yaffs_nand.h" + +#include "yaffs_yaffs1.h" +#include "yaffs_yaffs2.h" +#include "yaffs_bitmap.h" +#include "yaffs_verify.h" + +#include "yaffs_nand.h" +#include "yaffs_packedtags2.h" + +#include "yaffs_nameval.h" +#include "yaffs_allocator.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); + +/* 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 yaffs_obj_t *yaffs_new_obj (yaffs_dev_t *dev,int number, +yaffs_obj_type type); + + +static int yaffs_apply_xattrib_mod (yaffs_obj_t *obj,char *buffer,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 int yaffs_check_chunk_erased (struct yaffs_dev_s *dev, +int nand_chunk); + +static int yaffs_unlink_worker (yaffs_obj_t *obj); + +static int yaffs_tags_match (const 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 void yaffs_check_obj_details_loaded (yaffs_obj_t *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 int yaffs_find_chunk_in_file (yaffs_obj_t *in,int inode_chunk, +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); + + +/* 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) +{ +int chunk; +__u32 offset; + + chunk = (__u32)(addr >> dev->chunk_shift); + +if (dev->chunk_div ==1 ) { +/* easy power of 2 case */ + offset = (__u32)(addr & dev->chunk_mask); + }else { +/* Non power-of-2 case */ + +loff_t chunk_base; + + chunk /= dev->chunk_div; + + chunk_base = ((loff_t )chunk) * dev->data_bytes_per_chunk; + offset = (__u32)(addr - chunk_base); + } + + *chunk_out = chunk; + *offset_out = offset; +} + +/* Function to return the number of shifts for a power of 2 greater than or +* equal to the given number +* Note we don't try to cater for all possible numbers and this does not have to +* be hellishly efficient. +*/ + +static __u32 calc_shifts_ceiling (__u32 x) +{ +int extra_bits; +int shifts; + + shifts = extra_bits =0 ; + +while (x >1 ) { +if (x &1 ) + extra_bits++; + x >>=1 ; + shifts++; + } + +if (extra_bits) + shifts++; + +return shifts; +} + +/* Function to return the number of shifts to get a 1 in bit 0 +*/ + +static __u32 calc_shifts (__u32 x) +{ +__u32 shifts; + + shifts =0 ; + +if (!x) +return 0 ; + +while (!(x&1 )) { + x >>=1 ; + shifts++; + } + +return shifts; +} + + + +/* +* Temporary buffer manipulations. +*/ + +static int yaffs_init_tmp_buffers (yaffs_dev_t *dev) +{ +int i; +__u8 *buf = (__u8 *)1 ; + +memset (dev->temp_buffer,0 ,sizeof (dev->temp_buffer)); + +for (i =0 ; buf && i <YAFFS_N_TEMP_BUFFERS ; i++) { + dev->temp_buffer[i].line =0 ;/* not in use */ + dev->temp_buffer[i].buffer = buf = +YMALLOC_DMA (dev->param.total_bytes_per_chunk); + } + +return buf ?YAFFS_OK :YAFFS_FAIL ; +} + +__u8 *yaffs_get_temp_buffer (yaffs_dev_t *dev,int line_no) +{ +int i, j; + + dev->temp_in_use++; +if (dev->temp_in_use > dev->max_temp) + dev->max_temp = dev->temp_in_use; + +for (i =0 ; i <YAFFS_N_TEMP_BUFFERS ; i++) { +if (dev->temp_buffer[i].line ==0 ) { + dev->temp_buffer[i].line = line_no; +if ((i +1 ) > dev->max_temp) { + dev->max_temp = i +1 ; +for (j =0 ; j <= i; j++) + dev->temp_buffer[j].max_line = + dev->temp_buffer[j].line; + } + +return dev->temp_buffer[i].buffer; + } + } + +T (YAFFS_TRACE_BUFFERS , + (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 (" " TENDSTR ))); + +/* +* If we got here then we have to allocate an unmanaged one +* This is not good. +*/ + + dev->unmanaged_buffer_allocs++; +return YMALLOC (dev->data_bytes_per_chunk); + +} + +void yaffs_release_temp_buffer (yaffs_dev_t *dev,__u8 *buffer, +int line_no) +{ +int i; + + dev->temp_in_use--; + +for (i =0 ; i <YAFFS_N_TEMP_BUFFERS ; i++) { +if (dev->temp_buffer[i].buffer == buffer) { + dev->temp_buffer[i].line =0 ; +return ; + } + } + +if (buffer) { +/* assume it is an unmanaged one. */ +T (YAFFS_TRACE_BUFFERS , + (TSTR ("Releasing unmanaged temp buffer in line %d" TENDSTR ), + line_no)); +YFREE (buffer); + dev->unmanaged_buffer_deallocs++; + } + +} + +/* +* Determine if we have a managed buffer. +*/ +int yaffs_is_managed_tmp_buffer (yaffs_dev_t *dev,const __u8 *buffer) +{ +int i; + +for (i =0 ; i <YAFFS_N_TEMP_BUFFERS ; i++) { +if (dev->temp_buffer[i].buffer == buffer) +return 1 ; + } + +for (i =0 ; i < dev->param.n_caches; i++) { +if (dev->cache[i].data == buffer) +return 1 ; + } + +if (buffer == dev->checkpt_buffer) +return 1 ; + +T (YAFFS_TRACE_ALWAYS , + (TSTR ("yaffs: unmaged buffer detected.\n" TENDSTR ))); +return 0 ; +} + +/* +* Verification code +*/ + + + + +/* +* Simple hash function. Needs to have a reasonable spread +*/ + +static Y_INLINE int yaffs_hash_fn(int n) +{ + n =abs (n); +return n %YAFFS_NOBJECT_BUCKETS ; +} + +/* +* Access functions to useful fake objects. +* Note that root might have a presence in NAND if permissions are set. +*/ + +yaffs_obj_t *yaffs_root (yaffs_dev_t *dev) +{ +return dev->root_dir; +} + +yaffs_obj_t *yaffs_lost_n_found (yaffs_dev_t *dev) +{ +return dev->lost_n_found; +} + + +/* +* Erased NAND checking functions +*/ + +int yaffs_check_ff (__u8 *buffer,int n_bytes) +{ +/* Horrible, slow implementation */ +while (n_bytes--) { +if (*buffer !=0xFF ) +return 0 ; + buffer++; + } +return 1 ; +} + +static int yaffs_check_chunk_erased (struct yaffs_dev_s *dev, +int nand_chunk) +{ +int retval =YAFFS_OK ; +__u8 *data =yaffs_get_temp_buffer (dev, __LINE__); +yaffs_ext_tags tags; +int result; + + result =yaffs_rd_chunk_tags_nand (dev, nand_chunk, data, &tags); + +if (tags.ecc_result >YAFFS_ECC_RESULT_NO_ERROR ) + retval =YAFFS_FAIL ; + +if (!yaffs_check_ff (data, dev->data_bytes_per_chunk) || tags.chunk_used) { +T (YAFFS_TRACE_NANDACCESS , + (TSTR ("Chunk %d not erased" TENDSTR ), nand_chunk)); + retval =YAFFS_FAIL ; + } + +yaffs_release_temp_buffer (dev, data, __LINE__); + +return retval; + +} + + +static int yaffs_verify_chunk_written (yaffs_dev_t *dev, +int nand_chunk, +const __u8 *data, +yaffs_ext_tags *tags) +{ +int retval =YAFFS_OK ; +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) + retval =YAFFS_FAIL ; + +yaffs_release_temp_buffer (dev, buffer, __LINE__); + +return retval; +} + +static int yaffs_write_new_chunk (struct yaffs_dev_s *dev, +const __u8 *data, +yaffs_ext_tags *tags, +int use_reserver) +{ +int attempts =0 ; +int write_ok =0 ; +int chunk; + +yaffs2_checkpt_invalidate (dev); + +do { +yaffs_block_info_t *bi =0 ; +int erased_ok =0 ; + + chunk =yaffs_alloc_chunk (dev, use_reserver, &bi); +if (chunk <0 ) { +/* no space */ +break ; + } + +/* First check this chunk is erased, if it needs +* checking. The checking policy (unless forced +* always on) is as follows: +* +* 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... +* If the block has been erased, we don't need to check. +* +* However, if the block has been prioritised for gc, +* then we think there might be something odd about +* this block and stop using it. +* +* Rationale: We should only ever see chunks that have +* not been erased if there was a partially written +* chunk due to power loss. This checking policy should +* catch that case with very few checks and thus save a +* lot of checks that are most likely not needed. +* +* Mods to the above +* If an erase check fails or the write fails we skip the +* rest of the block. +*/ + +/* let's give it a try */ + attempts++; + +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)); + +/* 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); +continue ; + } + } + + 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 (write_ok !=YAFFS_OK ) { +/* Clean up aborted write, skip to next block and +* try another chunk */ +yaffs_handle_chunk_wr_error (dev, chunk, erased_ok); +continue ; + } + + bi->skip_erased_check =1 ; + +/* Copy the data into the robustification buffer */ +yaffs_handle_chunk_wr_ok (dev, chunk, data, tags); + + }while (write_ok !=YAFFS_OK && + (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)); + + dev->n_retired_writes += (attempts -1 ); + } + +return chunk; +} + + + +/* +* Block retiring for handling a broken block. +*/ + +static void yaffs_retire_block (yaffs_dev_t *dev,int flash_block) +{ +yaffs_block_info_t *bi =yaffs_get_block_info (dev, flash_block); + +yaffs2_checkpt_invalidate (dev); + +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)); + }else { +yaffs_ext_tags tags; +int chunk_id = flash_block * dev->param.chunks_per_block; + +__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)); + +yaffs_release_temp_buffer (dev, buffer, __LINE__); + } + } + + bi->block_state =YAFFS_BLOCK_STATE_DEAD ; + bi->gc_prioritise =0 ; + bi->needs_retiring =0 ; + + dev->n_retired_blocks++; +} + +/* +* Functions for robustisizing TODO +* +*/ + +static void yaffs_handle_chunk_wr_ok (yaffs_dev_t *dev,int nand_chunk, +const __u8 *data, +const yaffs_ext_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) +{ + dev=dev; + nand_chunk=nand_chunk; + tags=tags; +} + +void yaffs_handle_chunk_error (yaffs_dev_t *dev,yaffs_block_info_t *bi) +{ +if (!bi->gc_prioritise) { + bi->gc_prioritise =1 ; + dev->has_pending_prioritised_gc =1 ; + 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 ))); + + } + } +} + +static void yaffs_handle_chunk_wr_error (yaffs_dev_t *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); + +yaffs_handle_chunk_error (dev, bi); + +if (erased_ok) { +/* Was an actual write failure, so mark the block for retirement */ + bi->needs_retiring =1 ; +T (YAFFS_TRACE_ERROR |YAFFS_TRACE_BAD_BLOCKS , + (TSTR ("**>> Block %d needs retiring" TENDSTR ), flash_block)); + } + +/* Delete the chunk */ +yaffs_chunk_del (dev, nand_chunk,1 , __LINE__); +yaffs_skip_rest_of_block (dev); +} + + +/*---------------- Name handling functions ------------*/ + +static __u16 yaffs_calc_name_sum (const YCHAR *name) +{ +__u16 sum =0 ; +__u16 i =1 ; + +const YUCHAR *bname = (const YUCHAR *) name; +if (bname) { +while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH /2 ))) { + +#ifdef CONFIG_YAFFS_CASE_INSENSITIVE + sum +=yaffs_toupper (*bname) * i; +#else + sum += (*bname) * i; +#endif + i++; + bname++; + } + } +return sum; +} + +void yaffs_set_obj_name (yaffs_obj_t *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 ) +yaffs_strcpy (obj->short_name, name); +else + obj->short_name[0 ] =_Y ('\0' ); +#endif + obj->sum =yaffs_calc_name_sum (name); +} + +void yaffs_set_obj_name_from_oh (yaffs_obj_t *obj,const yaffs_obj_header *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); +#else +yaffs_set_obj_name (obj,oh->name); +#endif +} + +/*-------------------- TNODES ------------------- + +* List of spare tnodes +* The list is hooked together using the first pointer +* in the tnode. +*/ + + +yaffs_tnode_t *yaffs_get_tnode (yaffs_dev_t *dev) +{ +yaffs_tnode_t *tn =yaffs_alloc_raw_tnode (dev); +if (tn){ +memset (tn,0 , dev->tnode_size); + dev->n_tnodes++; + } + + 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) +{ +yaffs_free_raw_tnode (dev,tn); + dev->n_tnodes--; + dev->checkpoint_blocks_required =0 ;/* force recalculation*/ +} + +static void yaffs_deinit_tnodes_and_objs (yaffs_dev_t *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) +{ +__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; + + bit_in_map = pos * dev->tnode_width; + word_in_map = bit_in_map /32 ; + bit_in_word = bit_in_map & (32 -1 ); + + mask = dev->tnode_mask << bit_in_word; + + map[word_in_map] &= ~mask; + map[word_in_map] |= (mask & (val << bit_in_word)); + +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); + 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 *map = (__u32 *)tn; +__u32 bit_in_map; +__u32 bit_in_word; +__u32 word_in_map; +__u32 val; + + pos &=YAFFS_TNODES_LEVEL0_MASK ; + + bit_in_map = pos * dev->tnode_width; + word_in_map = bit_in_map /32 ; + bit_in_word = bit_in_map & (32 -1 ); + + val = map[word_in_map] >> 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); + } + + val &= dev->tnode_mask; + val <<= dev->chunk_grp_bits; + +return val; +} + +/* ------------------- End of individual tnode manipulation -----------------*/ + +/* ---------Functions to manipulate the look-up tree (made up of tnodes) ------ +* The look up tree is represented by the top tnode and the number of top_level +* in the tree. 0 means only the level 0 tnode is in the tree. +*/ + +/* 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) +{ +yaffs_tnode_t *tn = file_struct->top; +__u32 i; +int required_depth; +int level = file_struct->top_level; + + dev=dev; + +/* Check sane level and chunk Id */ +if (level <0 || level >YAFFS_TNODES_MAX_LEVEL ) +return NULL ; + +if (chunk_id >YAFFS_MAX_CHUNK_ID ) +return NULL ; + +/* First check we're tall enough (ie enough top_level) */ + + i = chunk_id >>YAFFS_TNODES_LEVEL0_BITS ; + required_depth =0 ; +while (i) { + i >>=YAFFS_TNODES_INTERNAL_BITS ; + required_depth++; + } + +if (required_depth > file_struct->top_level) +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 ]; + level--; + } + +return tn; +} + +/* AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree. +* This happens in two steps: +* 1. If the tree isn't tall enough, then make it taller. +* 2. Scan down the tree towards the level 0 tnode adding tnodes if required. +* +* Used when modifying the tree. +* +* If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will +* 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) +{ +int required_depth; +int i; +int l; +yaffs_tnode_t *tn; + +__u32 x; + + +/* Check sane level and page Id */ +if (file_struct->top_level <0 || file_struct->top_level >YAFFS_TNODES_MAX_LEVEL ) +return NULL ; + +if (chunk_id >YAFFS_MAX_CHUNK_ID ) +return NULL ; + +/* First check we're tall enough (ie enough top_level) */ + + x = chunk_id >>YAFFS_TNODES_LEVEL0_BITS ; + required_depth =0 ; +while (x) { + x >>=YAFFS_TNODES_INTERNAL_BITS ; + 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++) { + + tn =yaffs_get_tnode (dev); + +if (tn) { + tn->internal[0 ] = file_struct->top; + file_struct->top = tn; + file_struct->top_level++; + }else { +T (YAFFS_TRACE_ERROR , + (TSTR ("yaffs: no more tnodes" TENDSTR ))); +return NULL ; + } + } + } + +/* Traverse down to level 0, adding anything we need */ + + l = file_struct->top_level; + tn = file_struct->top; + +if (l >0 ) { +while (l >0 && tn) { + x = (chunk_id >> + (YAFFS_TNODES_LEVEL0_BITS + + (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]) +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 (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]) +return NULL ; + } + } + + tn = tn->internal[x]; + l--; + } + }else { +/* top is level 0 */ +if (passed_tn) { +memcpy (tn, passed_tn, (dev->tnode_width *YAFFS_NTNODES_LEVEL0 )/8 ); +yaffs_free_tnode (dev, passed_tn); + } + } + +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) +{ +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 ) +return the_chunk; +else { +yaffs_rd_chunk_tags_nand (dev, the_chunk,NULL , + tags); +if (yaffs_tags_match (tags, obj_id, inode_chunk)) { +/* found it; */ +return the_chunk; + } + } + } + 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) +{ +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; +unsigned block_no; + +T (YAFFS_TRACE_DELETION , (TSTR ("soft delete chunk %d" TENDSTR ), chunk)); + + 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++; + dev->n_free_chunks++; +yaffs2_update_oldest_dirty_seq (dev, block_no, the_block); + } +} + +/* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all the chunks in the file. +* All soft deleting does is increment the block's softdelete count and pulls the chunk out +* of the tnode. +* 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) +{ +int i; +int the_chunk; +int all_done =1 ; +yaffs_dev_t *dev = in->my_dev; + +if (tn) { +if (level >0 ) { + +for (i =YAFFS_NTNODES_INTERNAL -1 ; all_done && i >=0 ; + i--) { +if (tn->internal[i]) { + all_done = +yaffs_soft_del_worker (in, + 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] =NULL ; + }else { +/* Hoosterman... how could this happen? */ + } + } + } +return (all_done) ?1 :0 ; + }else if (level ==0 ) { + +for (i =YAFFS_NTNODES_LEVEL0 -1 ; i >=0 ; i--) { + the_chunk =yaffs_get_group_base (dev, tn, i); +if (the_chunk) { +/* Note this does not find the real chunk, only the chunk group. +* We make an assumption that a chunk group is not larger than +* a block. +*/ +yaffs_soft_del_chunk (dev, the_chunk); +yaffs_load_tnode_0 (dev, tn, i,0 ); + } + + } +return 1 ; + + } + + } + +return 1 ; + +} + +static void yaffs_soft_del_file (yaffs_obj_t *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 =NULL ; +T (YAFFS_TRACE_TRACING , + (TSTR ("yaffs: Deleting empty file %d" TENDSTR ), + obj->obj_id)); +yaffs_generic_obj_del (obj); + }else { +yaffs_soft_del_worker (obj, + obj->variant.file_variant.top, + obj->variant.file_variant. + top_level,0 ); + obj->soft_del =1 ; + } + } +} + +/* Pruning removes any part of the file structure tree that is beyond the +* bounds of the file (ie that does not point to chunks). +* +* A file should only get pruned when its size is reduced. +* +* Before pruning, the chunks must be pulled from the tree and the +* level 0 tnode entries must be zeroed out. +* Could also use this for file deletion, but that's probably better handled +* by a special case. +* +* This function is recursive. For levels > 0 the function is called again on +* any sub-tree. For level == 0 we just check if the sub-tree has data. +* 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) +{ +int i; +int has_data; + +if (tn) { + has_data =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 ); + } + +if (tn->internal[i]) + has_data++; + } + }else { +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++; + } + } + +if (has_data ==0 && del0) { +/* Free and return NULL */ + +yaffs_free_tnode (dev, tn); + tn =NULL ; + } + + } + +return tn; + +} + +static int yaffs_prune_tree (yaffs_dev_t *dev, +yaffs_file_s *file_struct) +{ +int i; +int has_data; +int done =0 ; +yaffs_tnode_t *tn; + +if (file_struct->top_level >0 ) { + file_struct->top = +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. +* Let's see if we can trim internal tnodes to shorten the tree. +* We can do this if only the 0th element in the tnode is in use +* (ie all the non-zero are NULL) +*/ + +while (file_struct->top_level && !done) { + tn = file_struct->top; + + has_data =0 ; +for (i =1 ; i <YAFFS_NTNODES_INTERNAL ; i++) { +if (tn->internal[i]) + has_data++; + } + +if (!has_data) { + file_struct->top = tn->internal[0 ]; + file_struct->top_level--; +yaffs_free_tnode (dev, tn); + }else { + done =1 ; + } + } + } + +return YAFFS_OK ; +} + +/*-------------------- 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) +{ +yaffs_obj_t *obj =yaffs_alloc_raw_obj (dev); + +if (obj) { + dev->n_obj++; + +/* Now sweeten it up... */ + +memset (obj,0 ,sizeof (yaffs_obj_t)); + 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); + + +/* 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); + } + +/* Add it to the lost and found directory. +* NB Can't put root or lost-n-found in lost-n-found so +* check if lost-n-found exists first +*/ +if (dev->lost_n_found) +yaffs_add_obj_to_dir (dev->lost_n_found, obj); + + obj->being_created =0 ; + } + + 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) +{ + +yaffs_obj_t *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->rename_allowed =0 ;/* ... and we're not allowed to rename it... */ + obj->unlink_allowed =0 ;/* ... or unlink it */ + obj->deleted =0 ; + obj->unlinked =0 ; + obj->yst_mode = mode; + obj->my_dev = dev; + obj->hdr_chunk =0 ;/* Not a valid chunk. */ + } + +return obj; + +} + +static void yaffs_unhash_obj (yaffs_obj_t *obj) +{ +int bucket; +yaffs_dev_t *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); + 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) +{ +yaffs_dev_t *dev = obj->my_dev; + +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)) +YBUG (); + + +if (obj->my_inode) { +/* We're still hooked up to a cached inode. +* Don't delete now, but mark for later deletion +*/ + obj->defered_free =1 ; +return ; + } + +yaffs_unhash_obj (obj); + +yaffs_free_raw_obj (dev,obj); + dev->n_obj--; + dev->checkpoint_blocks_required =0 ;/* force recalculation*/ +} + + +void yaffs_handle_defered_free (yaffs_obj_t *obj) +{ +if (obj->defered_free) +yaffs_free_obj (obj); +} + +static void yaffs_init_tnodes_and_objs (yaffs_dev_t *dev) +{ +int i; + + dev->n_obj =0 ; + dev->n_tnodes =0 ; + +yaffs_init_raw_tnodes_and_objs (dev); + +for (i =0 ; i <YAFFS_NOBJECT_BUCKETS ; i++) { +YINIT_LIST_HEAD (&dev->obj_bucket[i].list); + dev->obj_bucket[i].count =0 ; + } +} + +static int yaffs_find_nice_bucket (yaffs_dev_t *dev) +{ +int i; +int l =999 ; +int lowest =999999 ; + + +/* Search for the shortest list or one that +* isn't too long. +*/ + +for (i =0 ; i <10 && lowest >4 ; i++) { + dev->bucket_finder++; + dev->bucket_finder %=YAFFS_NOBJECT_BUCKETS ; +if (dev->obj_bucket[dev->bucket_finder].count < lowest) { + lowest = dev->obj_bucket[dev->bucket_finder].count; + l = dev->bucket_finder; + } + + } + +return l; +} + +static int yaffs_new_obj_id (yaffs_dev_t *dev) +{ +int bucket =yaffs_find_nice_bucket (dev); + +/* Now find an object value that has not already been taken +* by scanning the list. +*/ + +int found =0 ; +struct ylist_head *i; + +__u32 n = (__u32 ) bucket; + +/* yaffs_check_obj_hash_sane(); */ + +while (!found) { + found =1 ; + n +=YAFFS_NOBJECT_BUCKETS ; +if (1 || dev->obj_bucket[bucket].count >0 ) { +ylist_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) { + found =0 ; + } + } + } + } + +return n; +} + +static void yaffs_hash_obj (yaffs_obj_t *in) +{ +int bucket =yaffs_hash_fn (in->obj_id); +yaffs_dev_t *dev = in->my_dev; + +ylist_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) +{ +int bucket =yaffs_hash_fn (number); +struct ylist_head *i; +yaffs_obj_t *in; + +ylist_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); +if (in->obj_id == number) { + +/* Don't tell the VFS about this one if it is defered free */ +if (in->defered_free) +return NULL ; + +return in; + } + } + } + +return NULL ; +} + +yaffs_obj_t *yaffs_new_obj (yaffs_dev_t *dev,int number, +yaffs_obj_type type) +{ +yaffs_obj_t *the_obj=NULL ; +yaffs_tnode_t *tn =NULL ; + +if (number <0 ) + number =yaffs_new_obj_id (dev); + +if (type ==YAFFS_OBJECT_TYPE_FILE ) { + tn =yaffs_get_tnode (dev); +if (!tn) +return NULL ; + } + + the_obj =yaffs_alloc_empty_obj (dev); +if (!the_obj){ +if (tn) +yaffs_free_tnode (dev,tn); +return NULL ; + } + + +if (the_obj) { + the_obj->fake =0 ; + the_obj->rename_allowed =1 ; + the_obj->unlink_allowed =1 ; + 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 ]; + +#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.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); +break ; +case YAFFS_OBJECT_TYPE_SYMLINK : +case YAFFS_OBJECT_TYPE_HARDLINK : +case YAFFS_OBJECT_TYPE_SPECIAL : +/* No action required */ +break ; +case YAFFS_OBJECT_TYPE_UNKNOWN : +/* todo this should not happen */ +break ; + } + } + +return the_obj; +} + +yaffs_obj_t *yaffs_find_or_create_by_number (yaffs_dev_t *dev, +int number, +yaffs_obj_type type) +{ +yaffs_obj_t *the_obj =NULL ; + +if (number >0 ) + the_obj =yaffs_find_by_number (dev, number); + +if (!the_obj) + the_obj =yaffs_new_obj (dev, number, type); + +return the_obj; + +} + + +YCHAR *yaffs_clone_str (const YCHAR *str) +{ +YCHAR *new_str =NULL ; +int len; + +if (!str) + str =_Y ("" ); + + len =yaffs_strnlen (str,YAFFS_MAX_ALIAS_LENGTH ); + new_str =YMALLOC ((len +1 ) *sizeof (YCHAR )); +if (new_str){ +yaffs_strncpy (new_str, str,len); + new_str[len] =0 ; + } +return new_str; + +} + +/* +* Mknod (create) a new object. +* equiv_obj only has meaning for a hard link; +* alias_str only has meaning for a symlink. +* 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) +{ +yaffs_obj_t *in; +YCHAR *str =NULL ; + +yaffs_dev_t *dev = parent->my_dev; + +/* 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 ; + +if (type ==YAFFS_OBJECT_TYPE_SYMLINK ) { + str =yaffs_clone_str (alias_str); +if (!str) +return NULL ; + } + + in =yaffs_new_obj (dev,-1 , type); + +if (!in){ +if (str) +YFREE (str); +return NULL ; + } + + + + + +if (in) { + in->hdr_chunk =0 ; + in->valid =1 ; + in->variant_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 ; + + in->yst_rdev = rdev; + in->yst_uid = uid; + in->yst_gid = gid; +#endif + in->n_data_chunks =0 ; + +yaffs_set_obj_name (in, name); + in->dirty =1 ; + +yaffs_add_obj_to_dir (parent, in); + + in->my_dev = parent->my_dev; + +switch (type) { +case YAFFS_OBJECT_TYPE_SYMLINK : + 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_id = + equiv_obj->obj_id; +ylist_add (&in->hard_links, &equiv_obj->hard_links); +break ; +case YAFFS_OBJECT_TYPE_FILE : +case YAFFS_OBJECT_TYPE_DIRECTORY : +case YAFFS_OBJECT_TYPE_SPECIAL : +case YAFFS_OBJECT_TYPE_UNKNOWN : +/* do nothing */ +break ; + } + +if (yaffs_update_oh (in, name,0 ,0 ,0 ,NULL ) <0 ) { +/* Could not create the object header, fail the creation */ +yaffs_del_obj (in); + in =NULL ; + } + +yaffs_update_parent (parent); + } + +return in; +} + +yaffs_obj_t *yaffs_create_file (yaffs_obj_t *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) +{ +return yaffs_create_obj (YAFFS_OBJECT_TYPE_DIRECTORY , parent, name, + 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) +{ +return yaffs_create_obj (YAFFS_OBJECT_TYPE_SPECIAL , parent, name, mode, + 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) +{ +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) +{ +/* Get the real object in case we were fed a hard link as an equivalent object */ + equiv_obj =yaffs_get_equivalent_obj (equiv_obj); + +if (yaffs_create_obj + (YAFFS_OBJECT_TYPE_HARDLINK , parent, name,0 ,0 ,0 , + equiv_obj,NULL ,0 )) { +return equiv_obj; + }else { +return NULL ; + } + +} + +static int yaffs_change_obj_name (yaffs_obj_t *obj,yaffs_obj_t *new_dir, +const YCHAR *new_name,int force,int shadows) +{ +int unlink_op; +int del_op; + +yaffs_obj_t *existing_target; + +if (new_dir ==NULL ) + new_dir = obj->parent;/* use the old directory */ + +if (new_dir->variant_type !=YAFFS_OBJECT_TYPE_DIRECTORY ) { +T (YAFFS_TRACE_ALWAYS , + (TSTR + ("tragedy: yaffs_change_obj_name: new_dir is not a directory" +TENDSTR ))); +YBUG (); + } + +/* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */ +if (obj->my_dev->param.is_yaffs2) + 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 ); + + del_op = (new_dir == obj->my_dev->del_dir); + + existing_target =yaffs_find_by_name (new_dir, new_name); + +/* If the object is a file going into the unlinked directory, +* then it is OK to just stuff it in since duplicate names are allowed. +* else only proceed if the new name does not exist and if we're putting +* it into a directory. +*/ +if ((unlink_op || + del_op || + force || + (shadows >0 ) || + !existing_target) && + new_dir->variant_type ==YAFFS_OBJECT_TYPE_DIRECTORY ) { +yaffs_set_obj_name (obj, new_name); + obj->dirty =1 ; + +yaffs_add_obj_to_dir (new_dir, obj); + +if (unlink_op) + 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 ) +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) +{ +yaffs_obj_t *obj =NULL ; +yaffs_obj_t *existing_target =NULL ; +int force =0 ; +int result; +yaffs_dev_t *dev; + + +if (!old_dir || old_dir->variant_type !=YAFFS_OBJECT_TYPE_DIRECTORY ) +YBUG (); +if (!new_dir || new_dir->variant_type !=YAFFS_OBJECT_TYPE_DIRECTORY ) +YBUG (); + + dev = old_dir->my_dev; + +#ifdef CONFIG_YAFFS_CASE_INSENSITIVE +/* Special case for case insemsitive systems (eg. WinCE). +* 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 ) +/* ENAMETOOLONG */ +return YAFFS_FAIL ; + + obj =yaffs_find_by_name (old_dir, old_name); + +if (obj && obj->rename_allowed) { + +/* Now do the handling for an existing target, if there is one */ + + 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)) { +/* 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) { +/* Nuke the target first, using shadowing, +* but only if it isn't the same object. +* +* Note we must disable gc otherwise it can mess up the shadowing. +* +*/ + dev->gc_disable=1 ; +yaffs_change_obj_name (obj, new_dir, new_name, force, + existing_target->obj_id); + existing_target->is_shadowed =1 ; +yaffs_unlink_obj (existing_target); + 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) +yaffs_update_parent (new_dir); + +return result; + } +return YAFFS_FAIL ; +} + +/*------------------------- Block Management and Page Allocation ----------------*/ + +static int yaffs_init_blocks (yaffs_dev_t *dev) +{ +int n_blocks = dev->internal_end_block - dev->internal_start_block +1 ; + + dev->block_info =NULL ; + dev->chunk_bits =NULL ; + + 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)); +if (!dev->block_info) { + dev->block_info =YMALLOC_ALT (n_blocks *sizeof (yaffs_block_info_t)); + 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_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_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->chunk_bits,0 , dev->chunk_bit_stride * n_blocks); +return YAFFS_OK ; + } + +return YAFFS_FAIL ; +} + +static void yaffs_deinit_blocks (yaffs_dev_t *dev) +{ +if (dev->block_info_alt && dev->block_info) +YFREE_ALT (dev->block_info); +else if (dev->block_info) +YFREE (dev->block_info); + + dev->block_info_alt =0 ; + + dev->block_info =NULL ; + +if (dev->chunk_bits_alt && dev->chunk_bits) +YFREE_ALT (dev->chunk_bits); +else if (dev->chunk_bits) +YFREE (dev->chunk_bits); + dev->chunk_bits_alt =0 ; + dev->chunk_bits =NULL ; +} + +void yaffs_block_became_dirty (yaffs_dev_t *dev,int block_no) +{ +yaffs_block_info_t *bi =yaffs_get_block_info (dev, block_no); + +int erased_ok =0 ; + +/* If the block is still healthy erase it and mark as clean. +* If the block has had a data failure, then retire it. +*/ + +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" :"" )); + +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) + 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){ + dev->gc_dirtiest =0 ; + dev->gc_pages_in_use =0 ; + } + +if (!bi->needs_retiring) { +yaffs2_checkpt_invalidate (dev); + erased_ok =yaffs_erase_block (dev, block_no); +if (!erased_ok) { + dev->n_erase_failures++; +T (YAFFS_TRACE_ERROR |YAFFS_TRACE_BAD_BLOCKS , + (TSTR ("**>> Erasure failed %d" TENDSTR ), block_no)); + } + } + +if (erased_ok && + ((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 + (dev, block_no * dev->param.chunks_per_block + i)) { +T (YAFFS_TRACE_ERROR , + (TSTR + (">>Block %d erasure supposedly OK, but chunk %d not erased" +TENDSTR ), block_no, i)); + } + } + } + +if (erased_ok) { +/* Clean it up... */ + bi->block_state =YAFFS_BLOCK_STATE_EMPTY ; + bi->seq_number =0 ; + dev->n_erased_blocks++; + 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->gc_prioritise =0 ; +yaffs_clear_chunk_bits (dev, block_no); + +T (YAFFS_TRACE_ERASE , + (TSTR ("Erased block %d" TENDSTR ), block_no)); + }else { + dev->n_free_chunks -= dev->param.chunks_per_block;/* We lost a block of free space */ + +yaffs_retire_block (dev, block_no); +T (YAFFS_TRACE_ERROR |YAFFS_TRACE_BAD_BLOCKS , + (TSTR ("**>> Block %d retired" TENDSTR ), block_no)); + } +} + +static int yaffs_find_alloc_block (yaffs_dev_t *dev) +{ +int i; + +yaffs_block_info_t *bi; + +if (dev->n_erased_blocks <1 ) { +/* Hoosterman we've got a problem. +* Can't get space to gc +*/ +T (YAFFS_TRACE_ERROR , + (TSTR ("yaffs tragedy: no more erased blocks" TENDSTR ))); + +return -1 ; + } + +/* Find an empty block. */ + +for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + dev->alloc_block_finder++; +if (dev->alloc_block_finder < dev->internal_start_block + || dev->alloc_block_finder > dev->internal_end_block) { + dev->alloc_block_finder = dev->internal_start_block; + } + + bi =yaffs_get_block_info (dev, dev->alloc_block_finder); + +if (bi->block_state ==YAFFS_BLOCK_STATE_EMPTY ) { + bi->block_state =YAFFS_BLOCK_STATE_ALLOCATING ; + dev->seq_number++; + bi->seq_number = dev->seq_number; + dev->n_erased_blocks--; +T (YAFFS_TRACE_ALLOCATE , + (TSTR ("Allocated block %d, seq %d, %d left" TENDSTR ), + dev->alloc_block_finder, dev->seq_number, + dev->n_erased_blocks)); +return dev->alloc_block_finder; + } + } + +T (YAFFS_TRACE_ALWAYS , + (TSTR + ("yaffs tragedy: no more erased blocks, but there should have been %d" +TENDSTR ), dev->n_erased_blocks)); + +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 reserved_chunks; +int reserved_blocks = dev->param.n_reserved_blocks; +int checkpt_blocks; + + checkpt_blocks =yaffs_calc_checkpt_blocks_required (dev); + + 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) +{ +int ret_val; +yaffs_block_info_t *bi; + +if (dev->alloc_block <0 ) { +/* Get next block to allocate off */ + dev->alloc_block =yaffs_find_alloc_block (dev); + dev->alloc_page =0 ; + } + +if (!use_reserver && !yaffs_check_alloc_available (dev,1 )) { +/* Not enough space to allocate unless we're allowed to use the reserve. */ +return -1 ; + } + +if (dev->n_erased_blocks < dev->param.n_reserved_blocks + && dev->alloc_page ==0 ) { +T (YAFFS_TRACE_ALLOCATE , (TSTR ("Allocating reserve" TENDSTR ))); + } + +/* Next page please.... */ +if (dev->alloc_block >=0 ) { + bi =yaffs_get_block_info (dev, dev->alloc_block); + + ret_val = (dev->alloc_block * dev->param.chunks_per_block) + + dev->alloc_page; + bi->pages_in_use++; +yaffs_set_chunk_bit (dev, dev->alloc_block, + dev->alloc_page); + + dev->alloc_page++; + + dev->n_free_chunks--; + +/* If the block is full set the state to full */ +if (dev->alloc_page >= dev->param.chunks_per_block) { + bi->block_state =YAFFS_BLOCK_STATE_FULL ; + dev->alloc_block =-1 ; + } + +if (block_ptr) + *block_ptr = bi; + +return ret_val; + } + +T (YAFFS_TRACE_ERROR , + (TSTR ("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR ))); + +return -1 ; +} + +static int yaffs_get_erased_chunks (yaffs_dev_t *dev) +{ +int n; + + n = dev->n_erased_blocks * dev->param.chunks_per_block; + +if (dev->alloc_block >0 ) + n += (dev->param.chunks_per_block - dev->alloc_page); + +return n; + +} + +/* +* 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) +{ +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 ){ + 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) +{ +int old_chunk; +int new_chunk; +int mark_flash; +int ret_val =YAFFS_OK ; +int i; +int is_checkpt_block; +int matching_chunk; +int max_copies; + +int chunks_before =yaffs_get_erased_chunks (dev); +int chunks_after; + +yaffs_ext_tags tags; + +yaffs_block_info_t *bi =yaffs_get_block_info (dev, block); + +yaffs_obj_t *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)); + +/*yaffs_verify_free_chunks(dev); */ + +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)) { +T (YAFFS_TRACE_TRACING , + (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__); + +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 */ ; + 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++) { +if (yaffs_check_chunk_bit (dev, block, dev->gc_chunk)) { + +/* This page is in use and might need to be copied off */ + + max_copies--; + + mark_flash =1 ; + +yaffs_init_tags (&tags); + +yaffs_rd_chunk_tags_nand (dev, old_chunk, + buffer, &tags); + + 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)); + +if (object && !yaffs_skip_verification (dev)) { +if (tags.chunk_id ==0 ) + matching_chunk = object->hdr_chunk; +else if (object->soft_del) + matching_chunk = old_chunk;/* Defeat the test */ +else + 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)); + + } + +if (!object) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("page %d in gc has no object: %d %d %d " +TENDSTR ), old_chunk, + tags.obj_id, tags.chunk_id, tags.n_bytes)); + } + +if (object && + object->deleted && + 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. +* We have to decrement free chunks so this works out properly. +*/ + dev->n_free_chunks--; + bi->soft_del_pages--; + + object->n_data_chunks--; + +if (object->n_data_chunks <=0 ) { +/* remeber to clean up the object */ + dev->gc_cleanup_list[dev->n_clean_ups] = + tags.obj_id; + dev->n_clean_ups++; + } + mark_flash =0 ; + }else if (0 ) { +/* Todo object && object->deleted && object->n_data_chunks == 0 */ +/* Deleted object header with no data chunks. +* Can be discarded and the file deleted. +*/ + object->hdr_chunk =0 ; +yaffs_free_tnode (object->my_dev, + object->variant. + file_variant.top); + object->variant.file_variant.top =NULL ; +yaffs_generic_obj_del (object); + + }else if (object) { +/* It's either a data chunk in a live file or +* an ObjectHeader, so we're interested in it. +* NB Need to keep the ObjectHeaders of deleted files +* until the whole file has been deleted off +*/ + tags.serial_number++; + + dev->n_gc_copies++; + +if (tags.chunk_id ==0 ) { +/* It is an object Id, +* We need to nuke the shrinkheader flags first +* Also need to clean up shadowing. +* We no longer want the shrink_header flag since its work is done +* and if it is left in place it will mess up scanning. +*/ + +yaffs_obj_header *oh; + oh = (yaffs_obj_header *)buffer; + + oh->is_shrink =0 ; + tags.extra_is_shrink =0 ; + + oh->shadows_obj =0 ; + oh->inband_shadowed_obj_id =0 ; + 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; + } + +yaffs_verify_oh (object, oh, &tags,1 ); + new_chunk = +yaffs_write_new_chunk (dev,(__u8 *) oh, &tags,1 ); + }else + new_chunk = +yaffs_write_new_chunk (dev, buffer, &tags,1 ); + +if (new_chunk <0 ) { + ret_val =YAFFS_FAIL ; + }else { + +/* Ok, now fix up the Tnodes etc. */ + +if (tags.chunk_id ==0 ) { +/* It's a header */ + 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 ); + } + } + } + +if (ret_val ==YAFFS_OK ) +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 +* because checkpointing does not restore gc. +*/ + bi->block_state =YAFFS_BLOCK_STATE_FULL ; + }else { +/* The gc completed. */ +/* Do any required cleanups */ +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]); +if (object) { +yaffs_free_tnode (dev, + object->variant.file_variant. + top); + object->variant.file_variant.top =NULL ; +T (YAFFS_TRACE_GC , + (TSTR + ("yaffs: About to finally delete object %d" +TENDSTR ), object->obj_id)); +yaffs_generic_obj_del (object); + object->my_dev->n_deleted_files--; + } + + } + + + chunks_after =yaffs_get_erased_chunks (dev); +if (chunks_before >= chunks_after) { +T (YAFFS_TRACE_GC , + (TSTR + ("gc did not increase free chunks before %d after %d" +TENDSTR ), chunks_before, chunks_after)); + } + dev->gc_block =0 ; + dev->gc_chunk =0 ; + dev->n_clean_ups =0 ; + } + + dev->gc_disable =0 ; + +return ret_val; +} + +/* +* FindBlockForgarbageCollection is used to select the dirtiest block (or close enough) +* for garbage collection. +*/ + +static unsigned yaffs_find_gc_block (yaffs_dev_t *dev, +int aggressive, +int background) +{ +int i; +int iterations; +unsigned selected =0 ; +int prioritised =0 ; +int prioritised_exist =0 ; +yaffs_block_info_t *bi; +int threshold; + +/* First let's see if we need to grab a prioritised block */ +if (dev->has_pending_prioritised_gc && !aggressive) { + dev->gc_dirtiest =0 ; + bi = dev->block_info; +for (i = dev->internal_start_block; + 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)) { + selected = i; + prioritised =1 ; + } + } + bi++; + } + +/* +* If there is a prioritised block and none was selected then +* this happened because there is at least one old dirty block gumming +* up the works. Let's gc the oldest dirty block. +*/ + +if (prioritised_exist && + !selected && + dev->oldest_dirty_block >0 ) + selected = dev->oldest_dirty_block; + +if (!prioritised_exist)/* None found, so we can clear this */ + dev->has_pending_prioritised_gc =0 ; + } + +/* If we're doing aggressive GC then we are happy to take a less-dirty block, and +* search harder. +* else (we're doing a leasurely gc), then we only bother to do this if the +* block has only a few pages in use. +*/ + +if (!selected){ +int pages_used; +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 ; +else + max_threshold = dev->param.chunks_per_block/8 ; + +if (max_threshold <YAFFS_GC_PASSIVE_THRESHOLD ) + max_threshold =YAFFS_GC_PASSIVE_THRESHOLD ; + + threshold = background ? + (dev->gc_not_done +2 ) *2 :0 ; +if (threshold <YAFFS_GC_PASSIVE_THRESHOLD ) + threshold =YAFFS_GC_PASSIVE_THRESHOLD ; +if (threshold > max_threshold) + threshold = max_threshold; + + iterations = n_blocks /16 +1 ; +if (iterations >100 ) + iterations =100 ; + } + +for (i =0 ; + 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; + + 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)) { + 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) + selected = dev->gc_dirtiest; + } + +/* +* If nothing has been selected for a while, try selecting the oldest dirty +* because that's gumming up the works. +*/ + +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 ) { + 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; + }else + dev->gc_not_done =0 ; + } + +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)); + + dev->n_gc_blocks++; +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 ) + dev->refresh_skip--; + }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" :"" )); + } + +return selected; +} + +/* New garbage collector +* If we're very low on erased blocks then we do aggressive garbage collection +* otherwise we do "leasurely" garbage collection. +* Aggressive gc looks further (whole array) and will accept less dirty blocks. +* Passive gc only inspects smaller areas and will only accept more dirty blocks. +* +* 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) +{ +int aggressive =0 ; +int gc_ok =YAFFS_OK ; +int max_tries =0 ; +int min_erased; +int erased_chunks; +int checkpt_block_adjust; + +if (dev->param.gc_control && + (dev->param.gc_control (dev) &1 ) ==0 ) +return YAFFS_OK ; + +if (dev->gc_disable) { +/* Bail out so we don't get recursive gc */ +return YAFFS_OK ; + } + +/* This loop should pass the first time. +* We'll only see looping here if the collection does not increase space. +*/ + +do { + max_tries++; + + 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; + +/* 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 )) +break ; + +if (dev->gc_skip >20 ) + dev->gc_skip =20 ; +if (erased_chunks < dev->n_free_chunks/2 || + dev->gc_skip <1 || + background) + aggressive =0 ; +else { + dev->gc_skip--; +break ; + } + } + + dev->gc_skip =5 ; + +/* 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 ; + } +if (dev->gc_block <1 ) { + dev->gc_block =yaffs_find_gc_block (dev, aggressive, background); + dev->gc_chunk =0 ; + dev->n_clean_ups=0 ; + } + +if (dev->gc_block >0 ) { + dev->all_gcs++; +if (!aggressive) + dev->passive_gc_count++; + +T (YAFFS_TRACE_GC , + (TSTR + ("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 ) { +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)); + } + }while ((dev->n_erased_blocks < dev->param.n_reserved_blocks) && + (dev->gc_block >0 ) && + (max_tries <2 )); + +return aggressive ? gc_ok :YAFFS_OK ; +} + +/* +* yaffs_bg_gc() +* 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 erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; + +T (YAFFS_TRACE_BACKGROUND , (TSTR ("Background gc %u" TENDSTR ),urgency)); + +yaffs_check_gc (dev,1 ); +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) +{ +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) +{ +/*Get the Tnode, then get the level 0 offset chunk offset */ +yaffs_tnode_t *tn; +int the_chunk =-1 ; +yaffs_ext_tags local_tags; +int ret_val =-1 ; + +yaffs_dev_t *dev = in->my_dev; + +if (!tags) { +/* Passed a NULL, so use our own tags space */ + tags = &local_tags; + } + + tn =yaffs_find_tnode_0 (dev, &in->variant.file_variant, inode_chunk); + +if (tn) { + the_chunk =yaffs_get_group_base (dev, tn, inode_chunk); + + ret_val = +yaffs_find_chunk_in_group (dev, the_chunk, tags, in->obj_id, + inode_chunk); + } +return ret_val; +} + +static int yaffs_find_del_file_chunk (yaffs_obj_t *in,int inode_chunk, +yaffs_ext_tags *tags) +{ +/* Get the Tnode, then get the level 0 offset chunk offset */ +yaffs_tnode_t *tn; +int the_chunk =-1 ; +yaffs_ext_tags local_tags; + +yaffs_dev_t *dev = in->my_dev; +int ret_val =-1 ; + +if (!tags) { +/* Passed a NULL, so use our own tags space */ + tags = &local_tags; + } + + tn =yaffs_find_tnode_0 (dev, &in->variant.file_variant, inode_chunk); + +if (tn) { + + the_chunk =yaffs_get_group_base (dev, tn, inode_chunk); + + ret_val = +yaffs_find_chunk_in_group (dev, the_chunk, tags, in->obj_id, + inode_chunk); + +/* Delete the entry in the filestructure (if found) */ +if (ret_val !=-1 ) +yaffs_load_tnode_0 (dev, tn, inode_chunk,0 ); + } + +return ret_val; +} + + +int yaffs_put_chunk_in_file (yaffs_obj_t *in,int inode_chunk, +int nand_chunk,int in_scan) +{ +/* NB in_scan is zero unless scanning. +* For forward scanning, in_scan is > 0; +* for backward scanning in_scan is < 0 +* +* 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; +int existing_cunk; +yaffs_ext_tags existing_tags; +yaffs_ext_tags new_tags; +unsigned existing_serial, new_serial; + +if (in->variant_type !=YAFFS_OBJECT_TYPE_FILE ) { +/* Just ignore an attempt at putting a chunk into a non-file during scanning +* If it is not during Scanning then something went wrong! +*/ +if (!in_scan) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("yaffs tragedy:attempt to put data chunk into a non-file" +TENDSTR ))); +YBUG (); + } + +yaffs_chunk_del (dev, nand_chunk,1 , __LINE__); +return YAFFS_OK ; + } + + tn =yaffs_add_find_tnode_0 (dev, + &in->variant.file_variant, + inode_chunk, +NULL ); +if (!tn) +return YAFFS_FAIL ; + +if (!nand_chunk) +/* Dummy insert, bail now */ +return YAFFS_OK ; + + existing_cunk =yaffs_get_group_base (dev, tn, inode_chunk); + +if (in_scan !=0 ) { +/* If we're scanning then we need to test for duplicates +* NB This does not need to be efficient since it should only ever +* happen when the power fails during a write, then only one +* chunk should ever be affected. +* +* Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO +* Update: For backward scanning we don't need to re-read tags so this is quite cheap. +*/ + +if (existing_cunk >0 ) { +/* NB Right now existing chunk will not be real chunk_id if the chunk group size > 1 +* thus we have to do a FindChunkInFile to get the real chunk id. +* +* We have a duplicate now we need to decide which one to use: +* +* Backwards scanning YAFFS2: The old one is what we use, dump the new one. +* Forward scanning YAFFS2: The new one is what we use, dump the old one. +* YAFFS1: Get both sets of tags and compare serial numbers. +*/ + +if (in_scan >0 ) { +/* Only do this for forward scanning */ +yaffs_rd_chunk_tags_nand (dev, + nand_chunk, +NULL , &new_tags); + +/* Do a proper find */ + existing_cunk = +yaffs_find_chunk_in_file (in, inode_chunk, + &existing_tags); + } + +if (existing_cunk <=0 ) { +/*Hoosterman - how did this happen? */ + +T (YAFFS_TRACE_ERROR , + (TSTR + ("yaffs tragedy: existing chunk < 0 in scan" +TENDSTR ))); + + } + +/* NB The deleted flags should be false, otherwise the chunks will +* not be loaded during a scan +*/ + +if (in_scan >0 ) { + new_serial = new_tags.serial_number; + existing_serial = existing_tags.serial_number; + } + +if ((in_scan >0 ) && + (existing_cunk <=0 || + ((existing_serial +1 ) &3 ) == new_serial)) { +/* Forward scanning. +* Use new +* Delete the old one and drop through to update the tnode +*/ +yaffs_chunk_del (dev, existing_cunk,1 , + __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__); +return YAFFS_OK ; + } + } + + } + +if (existing_cunk ==0 ) + in->n_data_chunks++; + +yaffs_load_tnode_0 (dev, tn, inode_chunk, nand_chunk); + +return YAFFS_OK ; +} + +static int yaffs_rd_data_obj (yaffs_obj_t *in,int inode_chunk, +__u8 *buffer) +{ +int nand_chunk =yaffs_find_chunk_in_file (in, inode_chunk,NULL ); + +if (nand_chunk >=0 ) +return yaffs_rd_chunk_tags_nand (in->my_dev, nand_chunk, + buffer,NULL ); +else { +T (YAFFS_TRACE_NANDACCESS , + (TSTR ("Chunk %d not found zero instead" TENDSTR ), + nand_chunk)); +/* get sane (zero) data if you read a hole */ +memset (buffer,0 , in->my_dev->data_bytes_per_chunk); +return 0 ; + } + +} + +void yaffs_chunk_del (yaffs_dev_t *dev,int chunk_id,int mark_flash,int lyn) +{ +int block; +int page; +yaffs_ext_tags tags; +yaffs_block_info_t *bi; + +if (chunk_id <=0 ) +return ; + + dev->n_deletions++; + 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)); + + bi =yaffs_get_block_info (dev, block); + +yaffs2_update_oldest_dirty_seq (dev, block, bi); + +T (YAFFS_TRACE_DELETION , + (TSTR ("line %d delete of chunk %d" TENDSTR ), lyn, chunk_id)); + +if (!dev->param.is_yaffs2 && mark_flash && + bi->block_state !=YAFFS_BLOCK_STATE_COLLECTING ) { + +yaffs_init_tags (&tags); + + tags.is_deleted =1 ; + +yaffs_wr_chunk_tags_nand (dev, chunk_id,NULL , &tags); +yaffs_handle_chunk_update (dev, chunk_id, &tags); + }else { + dev->n_unmarked_deletions++; + } + +/* Pull out of the management area. +* If the whole block became dirty, this will kick off an erasure. +*/ +if (bi->block_state ==YAFFS_BLOCK_STATE_ALLOCATING || + bi->block_state ==YAFFS_BLOCK_STATE_FULL || + bi->block_state ==YAFFS_BLOCK_STATE_NEEDS_SCANNING || + bi->block_state ==YAFFS_BLOCK_STATE_COLLECTING ) { + dev->n_free_chunks++; + +yaffs_clear_chunk_bit (dev, block, page); + + bi->pages_in_use--; + +if (bi->pages_in_use ==0 && + !bi->has_shrink_hdr && + bi->block_state !=YAFFS_BLOCK_STATE_ALLOCATING && + bi->block_state !=YAFFS_BLOCK_STATE_NEEDS_SCANNING ) { +yaffs_block_became_dirty (dev, block); + } + + } + +} + +static int yaffs_wr_data_obj (yaffs_obj_t *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. +* Invalidate old tags. +*/ + +int prev_chunk_id; +yaffs_ext_tags prev_tags; + +int new_chunk_id; +yaffs_ext_tags new_tags; + +yaffs_dev_t *dev = in->my_dev; + +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 )) +return 0 ; + +/* Set up new tags */ +yaffs_init_tags (&new_tags); + + new_tags.chunk_id = inode_chunk; + new_tags.obj_id = in->obj_id; + new_tags.serial_number = + (prev_chunk_id >0 ) ? prev_tags.serial_number +1 :1 ; + new_tags.n_bytes = n_bytes; + +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)); +YBUG (); + } + + + new_chunk_id = +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 ); + +if (prev_chunk_id >0 ) +yaffs_chunk_del (dev, prev_chunk_id,1 , __LINE__); + +yaffs_verify_file_sane (in); + } +return new_chunk_id; + +} + +/* 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) +{ + +yaffs_block_info_t *bi;
Lines of this file are not shown. View the raw message.
drivers/staging/yaffs2/yaffs_guts.h new file +969 -0
969 lines not on this page · raw message
The rest of this diff is not shown. View the raw message.
Signature · 1 line
1.7.3.2.146.gca209
Part of the diff is not shown here. View the raw message.
Re: [PATCH 10/29] Staging: yaffs2: yaffs_guts: Add files
Quoted 5 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>--- drivers/staging/yaffs2/yaffs_guts.c | 5544
+++++++++++++++++++++++++++++++++++
Review
Quoted 6 lines
drivers/staging/yaffs2/yaffs_guts.h | 969 ++++++ 2 files changed, 6513 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_guts.c create mode 100644 drivers/staging/yaffs2/yaffs_guts.h(quoted diff) +0
-0
b/drivers/staging/yaffs2/yaffs_guts.c
drivers/staging/yaffs2/yaffs_guts.c line 2
Quoted 7 lines
new file mode 100644
index 0000000..eea828adrivers/staging/yaffs2/yaffs_guts.c new file +2
-0@@ -0,0 +1,5544 @@ +/* +* YAFFS: Yet Another Flash File System. A NAND-flash specific file
system.
Quoted 11 lines
drivers/staging/yaffs2/yaffs_guts.c new file +11
-0+* +* Copyright (C) 2002-2010 Aleph One Ltd. +* for Toby Churchill Ltd and Brightstar Engineering +* +* Created by Charles Manning <[email protected]> +* +* 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. +*/ +
drivers/staging/yaffs2/yaffs_guts.c line 23
Quoted 10 lines
drivers/staging/yaffs2/yaffs_guts.c new file +10
-0+#include "yportenv.h" +#include "yaffs_trace.h" + +#include "yaffs_guts.h" +#include "yaffs_tagsvalidity.h" +#include "yaffs_getblockinfo.h" + +#include "yaffs_tagscompat.h" + +#include "yaffs_nand.h"
^--- here
drivers/staging/yaffs2/yaffs_guts.c line 30
Quoted 7 lines
drivers/staging/yaffs2/yaffs_guts.c new file +7
-0+ +#include "yaffs_yaffs1.h" +#include "yaffs_yaffs2.h" +#include "yaffs_bitmap.h" +#include "yaffs_verify.h" + +#include "yaffs_nand.h"
^--- and here
duplicate inclusion of "yaffs_nand.h" header.
Signature · 3 lines
Jesper Juhl <[email protected]> http://www.chaosbits.net/ Plain text mails only, please http://www.expita.com/nomime.html Don't top-post http://www.catb.org/~esr/jargon/html/T/top-post.html
PATCH 11/29 Staging: yaffs2: yaffs_linux.h: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_linux.h | 43 ++++++++++++++++++++++++++++++++++ 1 files changed, 43 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_linux.h
drivers/staging/yaffs2/yaffs_linux.h new file +43 -0
@@ -0,0 +1,43 @@ +/* +* 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 <[email protected]> +* +* 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 __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 */ +int bg_running; +struct semaphore gross_lock;/* Gross locking semaphore */ +__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 task_struct *readdir_process; +unsigned mount_id; +}; + +#define yaffs_dev_to_lc (dev) ((struct yaffs_linux_context *)((dev)->os_context)) +#define yaffs_dev_to_mtd (dev) ((struct mtd_info *)((dev)->driver_context)) + +#endif +
Signature · 1 line
1.7.3.2.146.gca209
PATCH 12/29 Staging: yaffs2: yaffs_list.h: add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_list.h | 127 +++++++++++++++++++++++++++++++++++ 1 files changed, 127 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_list.h
drivers/staging/yaffs2/yaffs_list.h new file +127 -0
@@ -0,0 +1,127 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_LIST_H__ +#define __YAFFS_LIST_H__ + + +#include "yportenv.h" + +/* +* This is a simple doubly linked list implementation that matches the +* 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 */ +}; + + +/* Initialise a static list */ +#define YLIST_HEAD (name) \ +struct ylist_head name = { &(name), &(name)} + + + +/* Initialise a list head to an empty list */ +#define YINIT_LIST_HEAD (p) \ +do { \ + (p)->next = (p);\ + (p)->prev = (p); \ +} while (0) + + +/* Add an element to a list */ +static Y_INLINE void ylist_add(struct ylist_head *new_entry, +struct ylist_head *list) +{ +struct ylist_head *list_next = list->next; + + list->next = new_entry; + new_entry->prev = list; + new_entry->next = list_next; + list_next->prev = new_entry; + +} + +static Y_INLINE void ylist_add_tail(struct ylist_head *new_entry, +struct ylist_head *list) +{ +struct ylist_head *list_prev = list->prev; + + list->prev = new_entry; + new_entry->next = list; + new_entry->prev = list_prev; + list_prev->next = 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) +{ +struct ylist_head *list_next = entry->next; +struct ylist_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) +{ +ylist_del (entry); + entry->next = entry->prev = entry; +} + + +/* Test if the list is empty */ +static Y_INLINE int ylist_empty(struct ylist_head *entry) +{ +return (entry->next == entry); +} + + +/* ylist_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) \ + ((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 +*/ + +#define ylist_for_each (itervar, list) \ + for (itervar = (list)->next; itervar != (list); itervar = itervar->next) + +#define ylist_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) + + +#endif
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 12/29] Staging: yaffs2: yaffs_list.h: add file
Quoted 13 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_list.h | 127 +++++++++++++++++++++++++++++++++++1 files changed, 127 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_list.hdrivers/staging/yaffs2/yaffs_list.h new file +0
-0
drivers/staging/yaffs2/yaffs_list.h line 21
Quoted 6 lines
drivers/staging/yaffs2/yaffs_list.h new file +6
-0+/* +* 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. +* +*/
This header needs to die.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 13/29 Staging: yaffs2: yaffs_mtdif: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_mtdif.c | 56 ++++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_mtdif.h | 27 ++++++++++++++++ 2 files changed, 83 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_mtdif.c create mode 100644 drivers/staging/yaffs2/yaffs_mtdif.h
drivers/staging/yaffs2/yaffs_mtdif.c new file +56 -0
@@ -0,0 +1,56 @@ +/* +* 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 <[email protected]> +* +* 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 "yportenv.h" + + +#include "yaffs_mtdif.h" + +#include "linux/mtd/mtd.h" +#include "linux/types.h" +#include "linux/time.h" +#include "linux/mtd/nand.h" + +#include "yaffs_linux.h" + +int nandmtd_erase_block (yaffs_dev_t *dev,int block_no) +{ +struct mtd_info *mtd =yaffs_dev_to_mtd (dev); +__u32 addr = + ((loff_t ) block_no) * dev->param.total_bytes_per_chunk + * dev->param.chunks_per_block; +struct erase_info ei; + +int retval =0 ; + + ei.mtd = mtd; + ei.addr = addr; + ei.len = dev->param.total_bytes_per_chunk * dev->param.chunks_per_block; + ei.time =1000 ; + ei.retries =2 ; + ei.callback =NULL ; + ei.priv = (u_long ) dev; + + retval = mtd->erase (mtd, &ei); + +if (retval ==0 ) +return YAFFS_OK ; +else +return YAFFS_FAIL ; +} + +int nandmtd_initialise (yaffs_dev_t *dev) +{ +return YAFFS_OK ; +} +
drivers/staging/yaffs2/yaffs_mtdif.h new file +27 -0
@@ -0,0 +1,27 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_MTDIF_H__ +#define __YAFFS_MTDIF_H__ + +#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); +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 14/29 Staging: yaffs2: yaffs_mtdif1: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_mtdif1.c | 362 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_mtdif1.h | 28 +++ 2 files changed, 390 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_mtdif1.c create mode 100644 drivers/staging/yaffs2/yaffs_mtdif1.h
drivers/staging/yaffs2/yaffs_mtdif1.c new file +362 -0
@@ -0,0 +1,362 @@ +/* +* 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 <[email protected]> +* +* 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_tCompatability 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" + +/* Don't compile this module if we don't have MTD's mtd_oob_ops interface */ +#if (MTD_VERSION_CODE >MTD_VERSION (2 ,6 ,17 )) + +#ifndef CONFIG_YAFFS_9BYTE_TAGS +# define YTAG1_SIZE 8 +#else +# define YTAG1_SIZE 9 +#endif + +#if 0 +/* Use the following nand_ecclayout with MTD when using +* CONFIG_YAFFS_9BYTE_TAGS and the older on-NAND tags layout. +* If you have existing Yaffs images and the byte order differs from this, +* adjust 'oobfree' to match your existing Yaffs data. +* +* This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the +* page_status byte (at NAND spare offset 4) scattered/gathered from/to +* the 9th byte. +* +* Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5 +* We have/need packed_tags1 plus page_status: T0,T1,T2,T3,T4,T5,T6,T7,P +* where Tn are the tag bytes, En are MTD's ECC bytes, P is the page_status +* byte and B is the small-page bad-block indicator byte. +*/ +static struct nand_ecclayout nand_oob_16 = { + .eccbytes =6 , + .eccpos = {8 ,9 ,10 ,13 ,14 ,15 }, + .oobavail =9 , + .oobfree = { {0 ,4 }, {6 ,2 }, {11 ,2 }, {4 ,1 } } +}; +#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 (yaffs_dev_t *dev, +int nand_chunk,const __u8 *data,const 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; +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 ); + +yaffs_pack_tags1 (&pt1, etags); +yaffs_calc_tags_ecc ((yaffs_tags_t *)&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 (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 (yaffs_dev_t *dev, +int nand_chunk,__u8 *data,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; +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; + +#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; +* help it out with ops.len = ops.ooblen when ops.datbuf == NULL. +*/ + ops.len = (ops.datbuf) ? ops.len : ops.ooblen; +#endif +/* 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 ((yaffs_tags_t *)&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_s *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_s *dev,int block_no, +yaffs_block_state_t *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; +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 ; +} + +#endif /*MTD_VERSION*/
drivers/staging/yaffs2/yaffs_mtdif1.h new file +28 -0
@@ -0,0 +1,28 @@ +/* +* 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 +* +* 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 __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_read_chunk_tags (yaffs_dev_t *dev,int nand_chunk, +__u8 *data,yaffs_ext_tags *tags); + +int nandmtd1_mark_block_bad (struct yaffs_dev_s *dev,int block_no); + +int nandmtd1_query_block (struct yaffs_dev_s *dev,int block_no, +yaffs_block_state_t *state,__u32 *seq_number); + +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 15/29 Staging: yaffs2: yaffs_mtdif2: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_mtdif2.c | 256 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_mtdif2.h | 29 ++++ 2 files changed, 285 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_mtdif2.c create mode 100644 drivers/staging/yaffs2/yaffs_mtdif2.h
drivers/staging/yaffs2/yaffs_mtdif2.c new file +256 -0
@@ -0,0 +1,256 @@ +/* +* 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 <[email protected]> +* +* 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 (yaffs_dev_t *dev,int nand_chunk, +const __u8 *data, +const yaffs_ext_tags *tags) +{ +struct mtd_info *mtd =yaffs_dev_to_mtd (dev); +#if (MTD_VERSION_CODE >MTD_VERSION (2 ,6 ,17 )) +struct mtd_oob_ops ops; +#else +size_t dummy; +#endif +int retval =0 ; + +loff_t addr; + +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) { +yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = (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); + +#if (LINUX_VERSION_CODE >KERNEL_VERSION (2 ,6 ,17 )) + 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); + +#else +if (!dev->param.inband_tags) { + retval = + mtd->write_ecc (mtd, addr, dev->data_bytes_per_chunk, + &dummy, data, (__u8 *) packed_tags_ptr,NULL ); + }else { + retval = + mtd->write (mtd, addr, dev->param.total_bytes_per_chunk, &dummy, + data); + } +#endif + +if (retval ==0 ) +return YAFFS_OK ; +else +return YAFFS_FAIL ; +} + +int nandmtd2_read_chunk_tags (yaffs_dev_t *dev,int nand_chunk, +__u8 *data,yaffs_ext_tags *tags) +{ +struct mtd_info *mtd =yaffs_dev_to_mtd (dev); +#if (MTD_VERSION_CODE >MTD_VERSION (2 ,6 ,17 )) +struct mtd_oob_ops ops; +#endif +size_t dummy; +int retval =0 ; +int local_data =0 ; + +loff_t addr = ((loff_t ) nand_chunk) * dev->param.total_bytes_per_chunk; + +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 (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); +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); + } +#else +if (!dev->param.inband_tags && data && tags) { + + retval = mtd->read_ecc (mtd, addr, dev->data_bytes_per_chunk, + &dummy, data, dev->spare_buffer, +NULL ); + }else { +if (data) + retval = + 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, + dev->spare_buffer); + } +#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]; +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_s *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_s *dev,int block_no, +yaffs_block_state_t *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 { +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 ; +} +
drivers/staging/yaffs2/yaffs_mtdif2.h new file +29 -0
@@ -0,0 +1,29 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_MTDIF2_H__ +#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); + +#endif
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 15/29] Staging: yaffs2: yaffs_mtdif2: Add files
Quoted 15 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>--- drivers/staging/yaffs2/yaffs_mtdif2.c | 256 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_mtdif2.h | 29 ++++ 2 files changed, 285 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_mtdif2.c create mode 100644 drivers/staging/yaffs2/yaffs_mtdif2.hdrivers/staging/yaffs2/yaffs_mtdif2.c new file +0
-0
...
Quoted 10 lines
drivers/staging/yaffs2/yaffs_mtdif2.c new file +10
-0+#if (LINUX_VERSION_CODE >KERNEL_VERSION (2 ,6 ,17 )) + 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); + +#else
...
Quoted 4 lines
drivers/staging/yaffs2/yaffs_mtdif2.c new file +4
-0+#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);
drivers/staging/yaffs2/yaffs_mtdif2.c line 147
Quoted 10 lines
drivers/staging/yaffs2/yaffs_mtdif2.c new file +10
-0+ 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); + } +#else
...
If/when this code gets merged it will definitely be into a kernel with a version greater than 2.6.17, so I believe you should just get rid of the #ifdef and the code in the #else parts.
Signature · 3 lines
Jesper Juhl <[email protected]> http://www.chaosbits.net/ Plain text mails only, please http://www.expita.com/nomime.html Don't top-post http://www.catb.org/~esr/jargon/html/T/top-post.html
PATCH 16/29 Staging: yaffs2: yaffs_nameval: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_nameval.c | 197 ++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_nameval.h | 26 ++++ 2 files changed, 223 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_nameval.c create mode 100644 drivers/staging/yaffs2/yaffs_nameval.h
drivers/staging/yaffs2/yaffs_nameval.c new file +197 -0
@@ -0,0 +1,197 @@ +/* +* 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 <[email protected]> +* +* 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 simple implementation of a name-value store assumes a small number of values and fits +* into a small finite buffer. +* +* Each attribute is stored as a record: +* sizeof(int) bytes record size. +* strnlen+1 bytes name null terminated. +* nbytes value. +* ---------- +* total size stored in record size +* +* 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) +{ +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) + *exist_size = size; +return pos; + } + pos += size; +if (pos < xb_size -sizeof (int )) +memcpy (&size,xb + pos,sizeof (int )); +else + size =0 ; + } +if (exist_size) + *exist_size =0 ; +return -1 ; +} + +static int nval_used (const char *xb,int xb_size) +{ +int pos=0 ; +int 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 )); +else + size =0 ; + } +return pos; +} + +int nval_del (char *xb,int xb_size,const YCHAR *name) +{ +int pos =nval_find (xb, xb_size, name,NULL ); +int 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 (xb + pos, xb + pos + size, xb_size - (pos + 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 pos; +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); + +if (flags &XATTR_CREATE && pos >=0 ) +return -EEXIST ; +if (flags &XATTR_REPLACE && pos <0 ) +return -ENODATA ; + + start =nval_used (xb,xb_size); + space = xb_size - start + size_exist; + + reclen = (sizeof (int ) + namelen +1 + bsize); + +if (reclen > space) +return -ENOSPC ; + +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); +return 0 ; +} + +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 size; + +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){ + pos++; + size--; + } +/*Advance over NUL */ + pos++; + size--; + +if (size <= bsize){ +memcpy (buf,xb + pos,size); +return size; + } + + } +if (pos >=0 ) +return -ERANGE ; +else +return -ENODATA ; +} + +int nval_list (const char *xb,int xb_size,char *buf,int bsize) +{ +int pos =0 ; +int size; +int name_len; +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; + *buf ='\0' ; + buf++; +if (sizeof (YCHAR ) >1 ){ + *buf ='\0' ; + buf++; + } + ncopied += (name_len+1 ); + }else + filled =1 ; + 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 ; +}
drivers/staging/yaffs2/yaffs_nameval.h new file +26 -0
@@ -0,0 +1,26 @@ +/* +* 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 <[email protected]> +* +* 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 __NAMEVAL_H__ +#define __NAMEVAL_H__ + +#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_list (const char *xb,int xb_size,char *buf,int bsize); +int nval_hasvalues (const char *xb,int xb_size); +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 17/29 Staging: yaffs2: yaffs_nand: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_nand.c | 140 +++++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_nand.h | 44 +++++++++++ 2 files changed, 184 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_nand.c create mode 100644 drivers/staging/yaffs2/yaffs_nand.h
drivers/staging/yaffs2/yaffs_nand.c new file +140 -0
@@ -0,0 +1,140 @@ +/* +* 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 <[email protected]> +* +* 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_nand.h" +#include "yaffs_tagscompat.h" +#include "yaffs_tagsvalidity.h" + +#include "yaffs_getblockinfo.h" + +int yaffs_rd_chunk_tags_nand (yaffs_dev_t *dev,int nand_chunk, +__u8 *buffer, +yaffs_ext_tags *tags) +{ +int result; +yaffs_ext_tags local_tags; + +int realigned_chunk = nand_chunk - dev->chunk_offset; + + dev->n_page_reads++; + +/* If there are no tags provided, use local tags to get prioritised gc working */ +if (!tags) + tags = &local_tags; + +if (dev->param.read_chunk_tags_fn) + 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); +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) +{ + + dev->n_page_writes++; + + nand_chunk -= dev->chunk_offset; + + +if (tags) { + tags->seq_number = dev->seq_number; + tags->chunk_used =1 ; +if (!yaffs_validate_tags (tags)) { +T (YAFFS_TRACE_ERROR , + (TSTR ("Writing uninitialised tags" TENDSTR ))); +YBUG (); + } +T (YAFFS_TRACE_WRITE , + (TSTR ("Writing chunk %d tags %d %d" TENDSTR ), nand_chunk, + tags->obj_id, tags->chunk_id)); + }else { +T (YAFFS_TRACE_ERROR , (TSTR ("Writing with no tags" TENDSTR ))); +YBUG (); + } + +if (dev->param.write_chunk_tags_fn) +return dev->param.write_chunk_tags_fn (dev, nand_chunk, buffer, + tags); +else +return yaffs_tags_compat_wr (dev, + nand_chunk, + buffer, + tags); +} + +int yaffs_mark_bad (yaffs_dev_t *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) +{ + block_no -= dev->block_offset; + +if (dev->param.query_block_fn) +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); +} + + +int yaffs_erase_block (struct yaffs_dev_s *dev, +int flash_block) +{ +int result; + + flash_block -= dev->block_offset; + + dev->n_erasures++; + + result = dev->param.erase_fn (dev, flash_block); + +return result; +} + +int yaffs_init_nand (struct yaffs_dev_s *dev) +{ +if (dev->param.initialise_flash_fn) +return dev->param.initialise_flash_fn (dev); +return YAFFS_OK ; +} + + +
drivers/staging/yaffs2/yaffs_nand.h new file +44 -0
44 lines not on this page · raw message
Signature · 1 line
1.7.3.2.146.gca209
PATCH 18/29 Staging: yaffs2: yaffs_packedtags1: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_packedtags1.c | 50 ++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_packedtags1.h | 37 ++++++++++++++++++++ 2 files changed, 87 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_packedtags1.c create mode 100644 drivers/staging/yaffs2/yaffs_packedtags1.h
drivers/staging/yaffs2/yaffs_packedtags1.c new file +50 -0
@@ -0,0 +1,50 @@ +/* +* 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 <[email protected]> +* +* 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_packedtags1.h" +#include "yportenv.h" + +void yaffs_pack_tags1 (yaffs_packed_tags1 *pt,const yaffs_ext_tags *t) +{ + pt->chunk_id = t->chunk_id; + pt->serial_number = t->serial_number; + pt->n_bytes = t->n_bytes; + pt->obj_id = t->obj_id; + pt->ecc =0 ; + pt->deleted = (t->is_deleted) ?0 :1 ; + pt->unused_stuff =0 ; + pt->should_be_ff =0xFFFFFFFF ; + +} + +void yaffs_unpack_tags1 (yaffs_ext_tags *t,const yaffs_packed_tags1 *pt) +{ +static const __u8 all_ff[] = + {0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff ,0xff , +0xff }; + +if (memcmp (all_ff, pt,sizeof (yaffs_packed_tags1))) { + t->block_bad =0 ; +if (pt->should_be_ff !=0xFFFFFFFF ) + t->block_bad =1 ; + t->chunk_used =1 ; + t->obj_id = pt->obj_id; + t->chunk_id = pt->chunk_id; + t->n_bytes = pt->n_bytes; + t->ecc_result =YAFFS_ECC_RESULT_NO_ERROR ; + t->is_deleted = (pt->deleted) ?0 :1 ; + t->serial_number = pt->serial_number; + }else { +memset (t,0 ,sizeof (yaffs_ext_tags)); + } +}
drivers/staging/yaffs2/yaffs_packedtags1.h new file +37 -0
@@ -0,0 +1,37 @@ +/* +* 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 <[email protected]> +* +* 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 is used to pack YAFFS1 tags, not YAFFS2 tags. */ + +#ifndef __YAFFS_PACKEDTAGS1_H__ +#define __YAFFS_PACKEDTAGS1_H__ + +#include "yaffs_guts.h" + +typedef struct { +unsigned chunk_id:20 ; +unsigned serial_number:2 ; +unsigned n_bytes:10 ; +unsigned obj_id:18 ; +unsigned ecc:12 ; +unsigned deleted:1 ; +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); +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 19/29 Staging: yaffs2: yaffs_packedtags2: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_packedtags2.c | 198 ++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_packedtags2.h | 43 ++++++ 2 files changed, 241 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_packedtags2.c create mode 100644 drivers/staging/yaffs2/yaffs_packedtags2.h
drivers/staging/yaffs2/yaffs_packedtags2.c new file +198 -0
@@ -0,0 +1,198 @@ +/* +* 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 <[email protected]> +* +* 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_packedtags2.h" +#include "yportenv.h" +#include "yaffs_trace.h" +#include "yaffs_tagsvalidity.h" + +/* This code packs a set of extended tags into a binary structure for +* NAND storage +*/ + +/* Some of the information is "extra" struff which can be packed in to +* speed scanning +* This is defined by having the EXTRA_HEADER_INFO_FLAG set. +*/ + +/* Extra flags applied to chunk_id */ + +#define EXTRA_HEADER_INFO_FLAG 0x80000000 +#define EXTRA_SHRINK_FLAG 0x40000000 +#define EXTRA_SHADOWS_FLAG 0x20000000 +#define EXTRA_SPARE_FLAGS 0x10000000 + +#define ALL_EXTRA_FLAGS 0xF0000000 + +/* Also, the top 4 bits of the object Id are set to the object type. */ +#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) +{ +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)); +} +static void yaffs_dump_packed_tags2 (const yaffs_packed_tags2 *pt) +{ +yaffs_dump_packed_tags2_tags_only (&pt->t); +} + +static void yaffs_dump_tags2 (const yaffs_ext_tags *t) +{ +T (YAFFS_TRACE_MTD , + (TSTR + ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d" +TENDSTR ), t->ecc_result, t->block_bad, t->chunk_used, t->obj_id, + t->chunk_id, t->n_bytes, t->is_deleted, t->serial_number, + t->seq_number)); + +} + +void yaffs_pack_tags2_tags_only (yaffs_packed_tags2_tags_only *ptt, +const yaffs_ext_tags *t) +{ + ptt->chunk_id = t->chunk_id; + ptt->seq_number = t->seq_number; + ptt->n_bytes = t->n_bytes; + ptt->obj_id = t->obj_id; + +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; +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 ); + +if (t->extra_obj_type ==YAFFS_OBJECT_TYPE_HARDLINK ) + ptt->n_bytes = t->extra_equiv_id; +else if (t->extra_obj_type ==YAFFS_OBJECT_TYPE_FILE ) + ptt->n_bytes = t->extra_length; +else + ptt->n_bytes =0 ; + } + +yaffs_dump_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) +{ +yaffs_pack_tags2_tags_only (&pt->t, t); + +if (tags_ecc) +yaffs_ecc_calc_other ((unsigned char *)&pt->t, +sizeof (yaffs_packed_tags2_tags_only), + &pt->ecc); +} + + +void yaffs_unpack_tags2_tags_only (yaffs_ext_tags *t, +yaffs_packed_tags2_tags_only *ptt) +{ + +memset (t,0 ,sizeof (yaffs_ext_tags)); + +yaffs_init_tags (t); + +if (ptt->seq_number !=0xFFFFFFFF ) { + t->block_bad =0 ; + t->chunk_used =1 ; + t->obj_id = ptt->obj_id; + t->chunk_id = ptt->chunk_id; + t->n_bytes = ptt->n_bytes; + t->is_deleted =0 ; + t->serial_number =0 ; + t->seq_number = ptt->seq_number; + +/* Do extra header info stuff */ + +if (ptt->chunk_id &EXTRA_HEADER_INFO_FLAG ) { + t->chunk_id =0 ; + t->n_bytes =0 ; + + t->extra_available =1 ; + t->extra_parent_id = + ptt->chunk_id & (~(ALL_EXTRA_FLAGS )); + t->extra_is_shrink = + (ptt->chunk_id &EXTRA_SHRINK_FLAG ) ?1 :0 ; + t->extra_shadows = + (ptt->chunk_id &EXTRA_SHADOWS_FLAG ) ?1 :0 ; + t->extra_obj_type = + ptt->obj_id >>EXTRA_OBJECT_TYPE_SHIFT ; + t->obj_id &= ~EXTRA_OBJECT_TYPE_MASK ; + +if (t->extra_obj_type ==YAFFS_OBJECT_TYPE_HARDLINK ) + t->extra_equiv_id = ptt->n_bytes; +else + t->extra_length = ptt->n_bytes; + } + } + +yaffs_dump_packed_tags2_tags_only (ptt); +yaffs_dump_tags2 (t); + +} + + +void yaffs_unpack_tags2 (yaffs_ext_tags *t,yaffs_packed_tags2 *pt,int tags_ecc) +{ + +yaffs_ecc_result ecc_result =YAFFS_ECC_RESULT_NO_ERROR ; + +if (pt->t.seq_number !=0xFFFFFFFF && + tags_ecc){ +/* Chunk is in use and we need to do ECC */ + +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); +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 ; + } + } + +yaffs_unpack_tags2_tags_only (t, &pt->t); + + t->ecc_result = ecc_result; + +yaffs_dump_packed_tags2 (pt); +yaffs_dump_tags2 (t); +} +
drivers/staging/yaffs2/yaffs_packedtags2.h new file +43 -0
43 lines not on this page · raw message
Signature · 1 line
1.7.3.2.146.gca209
PATCH 20/29 Staging: yaffs2: yaffs_qsort.h: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_qsort.h | 34 ++++++++++++++++++++++++++++++++++ 1 files changed, 34 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_qsort.h
drivers/staging/yaffs2/yaffs_qsort.h new file +34 -0
@@ -0,0 +1,34 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_QSORT_H__ +#define __YAFFS_QSORT_H__ + +#ifdef __KERNEL__ +#include <linux/sort.h> + +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
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 20/29] Staging: yaffs2: yaffs_qsort.h: Add file
Quoted 21 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_qsort.h | 34 ++++++++++++++++++++++++++++++++++1 files changed, 34 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_qsort.hdrivers/staging/yaffs2/yaffs_qsort.h new file +8
-0+#ifndef __YAFFS_QSORT_H__ +#define __YAFFS_QSORT_H__ + +#ifdef __KERNEL__ +#include <linux/sort.h> + +extern void yaffs_qsort(void *const base, size_t total_elems, size_t size, + int (*cmp)(const void *, const void *)){
drivers/staging/yaffs2/yaffs_qsort.h line 34
Quoted 10 lines
drivers/staging/yaffs2/yaffs_qsort.h new file +10
-0+ 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
Kill this wrapper.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 21/29 Staging: yaffs2: yaffs_tagscompact: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_tagscompat.c | 539 +++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_tagscompat.h | 39 ++ 2 files changed, 578 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_tagscompat.c create mode 100644 drivers/staging/yaffs2/yaffs_tagscompat.h
drivers/staging/yaffs2/yaffs_tagscompat.c new file +539 -0
@@ -0,0 +1,539 @@ +/* +* 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 <[email protected]> +* +* 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_tagscompat.h" +#include "yaffs_ecc.h" +#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 const char yaffs_count_bits_table[256 ] = { +0 ,1 ,1 ,2 ,1 ,2 ,2 ,3 ,1 ,2 ,2 ,3 ,2 ,3 ,3 ,4 , +1 ,2 ,2 ,3 ,2 ,3 ,3 ,4 ,2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 , +1 ,2 ,2 ,3 ,2 ,3 ,3 ,4 ,2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 , +2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 ,3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 , +1 ,2 ,2 ,3 ,2 ,3 ,3 ,4 ,2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 , +2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 ,3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 , +2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 ,3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 , +3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 ,4 ,5 ,5 ,6 ,5 ,6 ,6 ,7 , +1 ,2 ,2 ,3 ,2 ,3 ,3 ,4 ,2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 , +2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 ,3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 , +2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 ,3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 , +3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 ,4 ,5 ,5 ,6 ,5 ,6 ,6 ,7 , +2 ,3 ,3 ,4 ,3 ,4 ,4 ,5 ,3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 , +3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 ,4 ,5 ,5 ,6 ,5 ,6 ,6 ,7 , +3 ,4 ,4 ,5 ,4 ,5 ,5 ,6 ,4 ,5 ,5 ,6 ,5 ,6 ,6 ,7 , +4 ,5 ,5 ,6 ,5 ,6 ,6 ,7 ,5 ,6 ,6 ,7 ,6 ,7 ,7 ,8 +}; + +int yaffs_count_bits (__u8 x) +{ +int ret_val; + ret_val = yaffs_count_bits_table[x]; +return ret_val; +} + +/********** Tags ECC calculations *********/ + +void yaffs_calc_ecc (const __u8 *data,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) +{ +/* Calculate an ecc */ + +unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; +unsigned i, j; +unsigned ecc =0 ; +unsigned bit =0 ; + + tags->ecc =0 ; + +for (i =0 ; i <8 ; i++) { +for (j =1 ; j &0xff ; j <<=1 ) { + bit++; +if (b[i] & j) + ecc ^= bit; + } + } + + tags->ecc = ecc; + +} + +int yaffs_check_tags_ecc (yaffs_tags_t *tags) +{ +unsigned ecc = tags->ecc; + +yaffs_calc_tags_ecc (tags); + + ecc ^= tags->ecc; + +if (ecc && ecc <=64 ) { +/* TODO: Handle the failure better. Retire? */ +unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; + + ecc--; + + b[ecc /8 ] ^= (1 << (ecc &7 )); + +/* Now recvalc the ecc */ +yaffs_calc_tags_ecc (tags); + +return 1 ;/* recovered error */ + }else if (ecc) { +/* Wierd ecc failure value */ +/* TODO Need to do somethiong here */ +return -1 ;/* unrecovered error */ + } + +return 0 ; +} + +/********** Tags **********/ + +static void yaffs_load_tags_to_spare (yaffs_spare *spare_ptr, +yaffs_tags_t *tags_ptr) +{ +yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr; + +yaffs_calc_tags_ecc (tags_ptr); + + spare_ptr->tb0 = tu->as_bytes[0 ]; + spare_ptr->tb1 = tu->as_bytes[1 ]; + spare_ptr->tb2 = tu->as_bytes[2 ]; + spare_ptr->tb3 = tu->as_bytes[3 ]; + spare_ptr->tb4 = tu->as_bytes[4 ]; + spare_ptr->tb5 = tu->as_bytes[5 ]; + spare_ptr->tb6 = tu->as_bytes[6 ]; + 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) +{ +yaffs_tags_union_t *tu = (yaffs_tags_union_t *) tags_ptr; +int result; + + tu->as_bytes[0 ] = spare_ptr->tb0; + tu->as_bytes[1 ] = spare_ptr->tb1; + tu->as_bytes[2 ] = spare_ptr->tb2; + tu->as_bytes[3 ] = spare_ptr->tb3; + tu->as_bytes[4 ] = spare_ptr->tb4; + tu->as_bytes[5 ] = spare_ptr->tb5; + tu->as_bytes[6 ] = spare_ptr->tb6; + tu->as_bytes[7 ] = spare_ptr->tb7; + + result =yaffs_check_tags_ecc (tags_ptr); +if (result >0 ) + dev->n_tags_ecc_fixed++; +else if (result <0 ) + dev->n_tags_ecc_unfixed++; +} + +static void yaffs_spare_init (yaffs_spare *spare) +{ +memset (spare,0xFF ,sizeof (yaffs_spare)); +} + +static int yaffs_wr_nand (struct yaffs_dev_s *dev, +int nand_chunk,const __u8 *data, +yaffs_spare *spare) +{ +if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { +T (YAFFS_TRACE_ERROR , + (TSTR ("**>> yaffs chunk %d is not valid" TENDSTR ), + nand_chunk)); +return YAFFS_FAIL ; + } + +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) +{ +int ret_val; +yaffs_spare local_spare; + +if (!spare && data) { +/* If we don't have a real spare, then we use a local one. */ +/* Need this for the calculation of the ecc */ + spare = &local_spare; + } + +if (!dev->param.use_nand_ecc) { + 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 ]; + +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); + +if (ecc_result1 >0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>yaffs ecc error fix performed on chunk %d:0" +TENDSTR ), nand_chunk)); + dev->n_ecc_fixed++; + }else if (ecc_result1 <0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>yaffs ecc error unfixed on chunk %d:0" +TENDSTR ), nand_chunk)); + dev->n_ecc_unfixed++; + } + +if (ecc_result2 >0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>yaffs ecc error fix performed on chunk %d:1" +TENDSTR ), nand_chunk)); + dev->n_ecc_fixed++; + }else if (ecc_result2 <0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>yaffs ecc error unfixed on chunk %d:1" +TENDSTR ), nand_chunk)); + dev->n_ecc_unfixed++; + } + +if (ecc_result1 || ecc_result2) { +/* We had a data problem on this page */ +yaffs_handle_rd_data_error (dev, nand_chunk); + } + +if (ecc_result1 <0 || ecc_result2 <0 ) + *ecc_result =YAFFS_ECC_RESULT_UNFIXED ; +else if (ecc_result1 >0 || ecc_result2 >0 ) + *ecc_result =YAFFS_ECC_RESULT_FIXED ; +else + *ecc_result =YAFFS_ECC_RESULT_NO_ERROR ; + } + }else { +/* Must allocate enough memory for spare+2*sizeof(int) */ +/* for ecc results from device. */ +struct yaffs_nand_spare nspare; + +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)); +if (data && correct_errors) { +if (nspare.eccres1 >0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>mtd ecc error fix performed on chunk %d:0" +TENDSTR ), nand_chunk)); + }else if (nspare.eccres1 <0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>mtd ecc error unfixed on chunk %d:0" +TENDSTR ), nand_chunk)); + } + +if (nspare.eccres2 >0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>mtd ecc error fix performed on chunk %d:1" +TENDSTR ), nand_chunk)); + }else if (nspare.eccres2 <0 ) { +T (YAFFS_TRACE_ERROR , + (TSTR + ("**>>mtd ecc error unfixed on chunk %d:1" +TENDSTR ), nand_chunk)); + } + +if (nspare.eccres1 || nspare.eccres2) { +/* We had a data problem on this page */ +yaffs_handle_rd_data_error (dev, nand_chunk); + } + +if (nspare.eccres1 <0 || nspare.eccres2 <0 ) + *ecc_result =YAFFS_ECC_RESULT_UNFIXED ; +else if (nspare.eccres1 >0 || nspare.eccres2 >0 ) + *ecc_result =YAFFS_ECC_RESULT_FIXED ; +else + *ecc_result =YAFFS_ECC_RESULT_NO_ERROR ; + + } + } +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) +{ +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 ; +T (YAFFS_TRACE_ERROR |YAFFS_TRACE_BAD_BLOCKS , + (TSTR ("**>>Block %d marked for retirement" TENDSTR ), flash_block)); + +/* TODO: +* Just do a garbage collection on the affected block +* then retire the block +* NB recursion +*/ +} + +#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) +{ +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; + +yaffs_spare_init (&spare); + +if (ext_tags->is_deleted) + spare.page_status =0 ; +else { + tags.obj_id = ext_tags->obj_id; + tags.chunk_id = ext_tags->chunk_id; + + tags.n_bytes_lsb = ext_tags->n_bytes &0x3ff ; + +if (dev->data_bytes_per_chunk >=1024 ) + tags.n_bytes_msb = (ext_tags->n_bytes >>10 ) &3 ; +else + tags.n_bytes_msb =3 ; + + + tags.serial_number = ext_tags->serial_number; + +if (!dev->param.use_nand_ecc && data) +yaffs_calc_ecc (data, &spare); + +yaffs_load_tags_to_spare (&spare, &tags); + + } + +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) +{ + +yaffs_spare spare; +yaffs_tags_t tags; +yaffs_ecc_result ecc_result =YAFFS_ECC_RESULT_UNKNOWN ; + +static yaffs_spare spare_ff; +static int init; + +if (!init) { +memset (&spare_ff,0xFF ,sizeof (spare_ff)); + init =1 ; + } + +if (yaffs_rd_chunk_nand + (dev, nand_chunk, data, &spare, &ecc_result,1 )) { +/* ext_tags may be NULL */ +if (ext_tags) { + +int deleted = + (yaffs_count_bits (spare.page_status) <7 ) ?1 :0 ; + + ext_tags->is_deleted = deleted; + ext_tags->ecc_result = ecc_result; + ext_tags->block_bad =0 ;/* We're reading it */ +/* therefore it is not a bad block */ + ext_tags->chunk_used = + (memcmp (&spare_ff, &spare,sizeof (spare_ff)) != +0 ) ?1 :0 ; + +if (ext_tags->chunk_used) { +yaffs_get_tags_from_spare (dev, &spare, &tags); + + ext_tags->obj_id = tags.obj_id; + ext_tags->chunk_id = tags.chunk_id; + 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->serial_number = tags.serial_number; + } + } + +return YAFFS_OK ; + }else { +return YAFFS_FAIL ; + } +} + +int yaffs_tags_compat_mark_bad (struct yaffs_dev_s *dev, +int flash_block) +{ + +yaffs_spare spare; + +memset (&spare,0xff ,sizeof (yaffs_spare)); + + spare.block_status ='Y' ; + +yaffs_wr_nand (dev, flash_block * dev->param.chunks_per_block,NULL , + &spare); +yaffs_wr_nand (dev, flash_block * dev->param.chunks_per_block +1 , +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) +{ + +yaffs_spare spare0, spare1; +static yaffs_spare spare_ff; +static int init; +yaffs_ecc_result dummy; + +if (!init) { +memset (&spare_ff,0xFF ,sizeof (spare_ff)); + init =1 ; + } + + *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 ); + +if (yaffs_count_bits (spare0.block_status & spare1.block_status) <7 ) + *state =YAFFS_BLOCK_STATE_DEAD ; +else if (memcmp (&spare_ff, &spare0,sizeof (spare_ff)) ==0 ) + *state =YAFFS_BLOCK_STATE_EMPTY ; +else + *state =YAFFS_BLOCK_STATE_NEEDS_SCANNING ; + +return YAFFS_OK ; +}
drivers/staging/yaffs2/yaffs_tagscompat.h new file +39 -0
@@ -0,0 +1,39 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_TAGSCOMPAT_H__ +#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); + +void yaffs_calc_tags_ecc (yaffs_tags_t *tags); +int yaffs_check_tags_ecc (yaffs_tags_t *tags); +int yaffs_count_bits (__u8 byte); + +#endif
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 21/29] Staging: yaffs2: yaffs_tagscompact: Add files
Quoted 15 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>--- drivers/staging/yaffs2/yaffs_tagscompat.c | 539 +++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_tagscompat.h | 39 ++ 2 files changed, 578 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_tagscompat.c create mode 100644 drivers/staging/yaffs2/yaffs_tagscompat.hdrivers/staging/yaffs2/yaffs_tagscompat.c new file +0
-0
[snip]
drivers/staging/yaffs2/yaffs_tagscompat.c line 54
Quoted 5 lines
drivers/staging/yaffs2/yaffs_tagscompat.c new file +5
-0+int yaffs_count_bits (__u8 x) +{ +int ret_val; + ret_val = yaffs_count_bits_table[x]; +return ret_val;
How about just getting rid of the unneeded temporary variable and just doing:
int yaffs_count_bits(__u8 x)
{
return yaffs_count_bits_table[x];
}??
[snip]
drivers/staging/yaffs2/yaffs_tagscompat.c line 74
Quoted 10 lines
drivers/staging/yaffs2/yaffs_tagscompat.c new file +10
-0+void yaffs_calc_tags_ecc (yaffs_tags_t *tags) +{ +/* Calculate an ecc */ + +unsigned char *b = ((yaffs_tags_union_t *) tags)->as_bytes; +unsigned i, j; +unsigned ecc =0 ; +unsigned bit =0 ; + + tags->ecc =0 ;
tags->ecc is not touched between here
drivers/staging/yaffs2/yaffs_tagscompat.c line 84
Quoted 10 lines
drivers/staging/yaffs2/yaffs_tagscompat.c new file +10
-0+ +for (i =0 ; i <8 ; i++) { +for (j =1 ; j &0xff ; j <<=1 ) { + bit++; +if (b[i] & j) + ecc ^= bit; + } + } + + tags->ecc = ecc;
and this assignment here, so the first 'tags->ecc = 0' assignment is pointless and should just go away IMHO.
drivers/staging/yaffs2/yaffs_tagscompat.c line 411
Quoted 13 lines
drivers/staging/yaffs2/yaffs_tagscompat.c new file +13
-0+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; + +yaffs_spare_init (&spare); + +if (ext_tags->is_deleted) + spare.page_status =0 ; +else {
purely a minor style issue, but I believe the kernel coding style here is to put curly braces for both the 'if' and 'else' branches if either requires them, so
if (ext_tags->is_deleted) {
spare.page_status = 0;
} else {
...
...
}[snip]
Quoted 43 lines
drivers/staging/yaffs2/yaffs_tagscompat.c new file +43
-0+int yaffs_tags_compat_rd (yaffs_dev_t *dev, +int nand_chunk, +__u8 *data, +yaffs_ext_tags *ext_tags) +{ + +yaffs_spare spare; +yaffs_tags_t tags; +yaffs_ecc_result ecc_result =YAFFS_ECC_RESULT_UNKNOWN ; + +static yaffs_spare spare_ff; +static int init; + +if (!init) { +memset (&spare_ff,0xFF ,sizeof (spare_ff)); + init =1 ; + } + +if (yaffs_rd_chunk_nand + (dev, nand_chunk, data, &spare, &ecc_result,1 )) { +/* ext_tags may be NULL */ +if (ext_tags) { + +int deleted = + (yaffs_count_bits (spare.page_status) <7 ) ?1 :0 ; + + ext_tags->is_deleted = deleted; + ext_tags->ecc_result = ecc_result; + ext_tags->block_bad =0 ;/* We're reading it */ +/* therefore it is not a bad block */ + ext_tags->chunk_used = + (memcmp (&spare_ff, &spare,sizeof (spare_ff)) != +0 ) ?1 :0 ; + +if (ext_tags->chunk_used) { +yaffs_get_tags_from_spare (dev, &spare, &tags); + + ext_tags->obj_id = tags.obj_id; + ext_tags->chunk_id = tags.chunk_id; + 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 );
drivers/staging/yaffs2/yaffs_tagscompat.c line 487
Quoted 10 lines
drivers/staging/yaffs2/yaffs_tagscompat.c new file +10
-0+ + ext_tags->serial_number = tags.serial_number; + } + } + +return YAFFS_OK ; + }else { +return YAFFS_FAIL ; + } +}
Indentation could be reduced with no negative effect by doing
if (!yaffs_rd_chunk_nand
(dev, nand_chunk, data, &spare, &ecc_result, 1))
return YAFFS_FAIL;...rest of function...
drivers/staging/yaffs2/yaffs_tagscompat.c line 496
Quoted 8 lines
drivers/staging/yaffs2/yaffs_tagscompat.c new file +8
-0+int yaffs_tags_compat_mark_bad (struct yaffs_dev_s *dev, +int flash_block) +{ + +yaffs_spare spare; + +memset (&spare,0xff ,sizeof (yaffs_spare)); +
Why is memset() used directly here, but elsewhere the yaffs_spare_init() function is used?
Signature · 3 lines
Jesper Juhl <[email protected]> http://www.chaosbits.net/ Plain text mails only, please http://www.expita.com/nomime.html Don't top-post http://www.catb.org/~esr/jargon/html/T/top-post.html
PATCH 22/29 Staging: yaffs2: yaffs_tagsvalidity: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_tagsvalidity.c | 28 +++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_tagsvalidity.h | 24 +++++++++++++++++++++++ 2 files changed, 52 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_tagsvalidity.c create mode 100644 drivers/staging/yaffs2/yaffs_tagsvalidity.h
drivers/staging/yaffs2/yaffs_tagsvalidity.c new file +28 -0
@@ -0,0 +1,28 @@ +/* +* 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 <[email protected]> +* +* 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_tagsvalidity.h" + +void yaffs_init_tags (yaffs_ext_tags *tags) +{ +memset (tags,0 ,sizeof (yaffs_ext_tags)); + tags->validity1 =0xAAAAAAAA ; + tags->validty1 =0x55555555 ; +} + +int yaffs_validate_tags (yaffs_ext_tags *tags) +{ +return (tags->validity1 ==0xAAAAAAAA && + tags->validty1 ==0x55555555 ); + +}
drivers/staging/yaffs2/yaffs_tagsvalidity.h new file +24 -0
@@ -0,0 +1,24 @@ +/* +* 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 <[email protected]> +* +* 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 __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); +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 23/29 Staging: yaffs2: yaffs_trace.h: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_trace.h | 60 ++++++++++++++++++++++++++++++++++ 1 files changed, 60 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_trace.h
drivers/staging/yaffs2/yaffs_trace.h new file +60 -0
@@ -0,0 +1,60 @@ +/* +* 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 <[email protected]> +* +* 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 __YTRACE_H__ +#define __YTRACE_H__ + +extern unsigned int yaffs_trace_mask; +extern unsigned int yaffs_wr_attempts; + +/* +* Tracing flags. +* The flags masked in YAFFS_TRACE_ALWAYS are always traced. +*/ + +#define YAFFS_TRACE_OS 0x00000002 +#define YAFFS_TRACE_ALLOCATE 0x00000004 +#define YAFFS_TRACE_SCAN 0x00000008 +#define YAFFS_TRACE_BAD_BLOCKS 0x00000010 +#define YAFFS_TRACE_ERASE 0x00000020 +#define YAFFS_TRACE_GC 0x00000040 +#define YAFFS_TRACE_WRITE 0x00000080 +#define YAFFS_TRACE_TRACING 0x00000100 +#define YAFFS_TRACE_DELETION 0x00000200 +#define YAFFS_TRACE_BUFFERS 0x00000400 +#define YAFFS_TRACE_NANDACCESS 0x00000800 +#define YAFFS_TRACE_GC_DETAIL 0x00001000 +#define YAFFS_TRACE_SCAN_DEBUG 0x00002000 +#define YAFFS_TRACE_MTD 0x00004000 +#define YAFFS_TRACE_CHECKPOINT 0x00008000 + +#define YAFFS_TRACE_VERIFY 0x00010000 +#define YAFFS_TRACE_VERIFY_NAND 0x00020000 +#define YAFFS_TRACE_VERIFY_FULL 0x00040000 +#define YAFFS_TRACE_VERIFY_ALL 0x000F0000 + +#define YAFFS_TRACE_SYNC 0x00100000 +#define YAFFS_TRACE_BACKGROUND 0x00200000 +#define YAFFS_TRACE_LOCK 0x00400000 + +#define YAFFS_TRACE_ERROR 0x40000000 +#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
Signature · 1 line
1.7.3.2.146.gca209
PATCH 24/29 Staging: yaffs2: yaffs_verify: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_verify.c | 631 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_verify.h | 41 +++ 2 files changed, 672 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_verify.c create mode 100644 drivers/staging/yaffs2/yaffs_verify.h
drivers/staging/yaffs2/yaffs_verify.c new file +631 -0
@@ -0,0 +1,631 @@ +/* +* 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 <[email protected]> +* +* 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_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) +{ + dev=dev; +return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY |YAFFS_TRACE_VERIFY_FULL )); +} + +static int yaffs_skip_full_verification (yaffs_dev_t *dev) +{ + dev=dev; +return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL )); +} + +static int yaffs_skip_nand_verification (yaffs_dev_t *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" +}; + + +void yaffs_verify_blk (yaffs_dev_t *dev,yaffs_block_info_t *bi,int n) +{ +int actually_used; +int in_use; + +if (yaffs_skip_verification (dev)) +return ; + +/* 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)); + +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])); + } + +/* 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)); + + +/* 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)); + +} + + + +void yaffs_verify_collected_blk (yaffs_dev_t *dev,yaffs_block_info_t *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)); + } +} + +void yaffs_verify_blocks (yaffs_dev_t *dev) +{ +int i; +int state_count[YAFFS_NUMBER_OF_BLOCK_STATES ]; +int illegal_states =0 ; + +if (yaffs_skip_verification (dev)) +return ; + +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); +yaffs_verify_blk (dev, bi, i); + +if (bi->block_state <YAFFS_NUMBER_OF_BLOCK_STATES ) + state_count[bi->block_state]++; +else + illegal_states++; + } + +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)); +if (state_count[YAFFS_BLOCK_STATE_ALLOCATING ] >1 ) +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])); + +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 ])); + +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 ])); + +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 ])); + +T (YAFFS_TRACE_VERIFY , (TSTR ("" TENDSTR ))); + +} + +/* +* 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) +{ +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)); +return ; + } + +if (oh->type <=YAFFS_OBJECT_TYPE_UNKNOWN || + 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)); + +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)); + + +/* +* Check that the object's parent ids match if parent_check requested. +* +* Tests do not apply to the root object. +*/ + +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)); + +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 )) +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)); + +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)); + +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)); +} + + +#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<<YAFFS_TNODES_INTERNAL_BITS ) + i); + } + } + }else if (level ==0 ) { +yaffs_ext_tags tags; +__u32 obj_id = obj->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) +{ +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; + +if (!obj) +return ; + +if (yaffs_skip_verification (obj->my_dev)) +return ; + + dev = obj->my_dev; + 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 ; + x = last_chunk >>YAFFS_TNODES_LEVEL0_BITS ; + required_depth =0 ; +while (x >0 ) { + x >>=YAFFS_TNODES_INTERNAL_BITS ; + required_depth++; + } + + actual_depth = obj->variant.file_variant.top_level; + +/* Check that the chunks in the tnode tree are all correct. +* We do this by scanning through the tnode tree and +* checking the tags for every chunk match. +*/ + +if (yaffs_skip_nand_verification (dev)) +return ; + +for (i =1 ; i <= last_chunk; i++) { + tn =yaffs_find_tnode_0 (dev, &obj->variant.file_variant, i); + +if (tn) { +__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); +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)); + } + } + } + } +} + + +void yaffs_verify_link (yaffs_obj_t *obj) +{ +if (obj &&yaffs_skip_verification (obj->my_dev)) +return ; + +/* Verify sane equivalent object */ +} + +void yaffs_verify_symlink (yaffs_obj_t *obj) +{ +if (obj &&yaffs_skip_verification (obj->my_dev)) +return ; + +/* Verify symlink string */ +} + +void yaffs_verify_special (yaffs_obj_t *obj) +{ +if (obj &&yaffs_skip_verification (obj->my_dev)) +return ; +} + +void yaffs_verify_obj (yaffs_obj_t *obj) +{ +yaffs_dev_t *dev; + +__u32 chunk_min; +__u32 chunk_max; + +__u32 chunk_id_ok; +__u32 chunk_in_range; +__u32 chunk_wrongly_deleted; +__u32 chunk_valid; + +if (!obj) +return ; + +if (obj->being_created) +return ; + + dev = obj->my_dev; + +if (yaffs_skip_verification (dev)) +return ; + +/* 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_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); + chunk_wrongly_deleted = chunk_in_range && !chunk_valid; + +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" :"" )); + } + +if (chunk_valid && !yaffs_skip_nand_verification (dev)) { +yaffs_ext_tags tags; +yaffs_obj_header *oh; +__u8 *buffer =yaffs_get_temp_buffer (dev, __LINE__); + + oh = (yaffs_obj_header *)buffer; + +yaffs_rd_chunk_tags_nand (dev, obj->hdr_chunk, buffer, + &tags); + +yaffs_verify_oh (obj, oh, &tags,1 ); + +yaffs_release_temp_buffer (dev, buffer, __LINE__); + } + +/* Verify it has a parent */ +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)); + } + +/* Verify parent is a 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)); + } + +switch (obj->variant_type) { +case YAFFS_OBJECT_TYPE_FILE : +yaffs_verify_file (obj); +break ; +case YAFFS_OBJECT_TYPE_SYMLINK : +yaffs_verify_symlink (obj); +break ; +case YAFFS_OBJECT_TYPE_DIRECTORY : +yaffs_verify_dir (obj); +break ; +case YAFFS_OBJECT_TYPE_HARDLINK : +yaffs_verify_link (obj); +break ; +case YAFFS_OBJECT_TYPE_SPECIAL : +yaffs_verify_special (obj); +break ; +case YAFFS_OBJECT_TYPE_UNKNOWN : +default : +T (YAFFS_TRACE_VERIFY , + (TSTR ("Obj %d has illegaltype %d" TENDSTR ), + obj->obj_id, obj->variant_type)); +break ; + } +} + +void yaffs_verify_objects (yaffs_dev_t *dev) +{ +yaffs_obj_t *obj; +int i; +struct ylist_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) { +if (lh) { + obj =ylist_entry (lh, yaffs_obj_t, hash_link); +yaffs_verify_obj (obj); + } + } + } +} + + +void yaffs_verify_obj_in_dir (yaffs_obj_t *obj) +{ +struct ylist_head *lh; +yaffs_obj_t *list_obj; + +int count =0 ; + +if (!obj) { +T (YAFFS_TRACE_ALWAYS , (TSTR ("No object to verify" TENDSTR ))); +YBUG (); +return ; + } + +if (yaffs_skip_verification (obj->my_dev)) +return ; + +if (!obj->parent) { +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 ))); +YBUG (); + } + +/* Iterate through the objects in each hash entry */ + +ylist_for_each (lh, &obj->parent->variant.dir_variant.children) { +if (lh) { + list_obj =ylist_entry (lh, yaffs_obj_t, 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)); +YBUG (); + } +} + +void yaffs_verify_dir (yaffs_obj_t *directory) +{ +struct ylist_head *lh; +yaffs_obj_t *list_obj; + +if (!directory) { +YBUG (); +return ; + } + +if (yaffs_skip_full_verification (directory->my_dev)) +return ; + +if (directory->variant_type !=YAFFS_OBJECT_TYPE_DIRECTORY ) { +T (YAFFS_TRACE_ALWAYS , + (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) { +if (lh) { + list_obj =ylist_entry (lh, yaffs_obj_t, siblings); +if (list_obj->parent != directory) { +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); + } + } +} + +static int yaffs_free_verification_failures; + +void yaffs_verify_free_chunks (yaffs_dev_t *dev) +{ +int counted; +int difference; + +if (yaffs_skip_verification (dev)) +return ; + + counted =yaffs_count_free_chunks (dev); + + difference = dev->n_free_chunks - counted; + +if (difference) { +T (YAFFS_TRACE_ALWAYS , + (TSTR ("Freechunks verification failure %d %d %d" TENDSTR ), + dev->n_free_chunks, counted, difference)); + yaffs_free_verification_failures++; + } +} + +int yaffs_verify_file_sane (yaffs_obj_t *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; +return YAFFS_OK ; +#endif +}
drivers/staging/yaffs2/yaffs_verify.h new file +41 -0
41 lines not on this page · raw message
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 24/29] Staging: yaffs2: yaffs_verify: Add files
Quoted 15 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>--- drivers/staging/yaffs2/yaffs_verify.c | 631 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_verify.h | 41 +++ 2 files changed, 672 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_verify.c create mode 100644 drivers/staging/yaffs2/yaffs_verify.hdrivers/staging/yaffs2/yaffs_verify.c new file +0
-0
...
Quoted 1 line
+#if 0
Why are you trying to merge new code that's under '#if 0' (and not just here, but elsewhere as well)?
Either it shouldn't be here, in which case it should just be omitted from the patch, or it needs to be here eventually in which case it should be fixed up so the '#if 0' can go away or simply just be added later when it has been fixed up.
Quoted 1 line
+/* Not being used, but don't want to throw away yet
*/ > +int yaffs_verify_tnode_worker(yaffs_obj_t *obj, yaffs_tnode_t *tn,
Quoted 31 lines
drivers/staging/yaffs2/yaffs_verify.c new file +31
-0+ __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<<YAFFS_TNODES_INTERNAL_BITS ) + i); + } + } + }else if (level ==0 ) { +yaffs_ext_tags tags; +__u32 obj_id = obj->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),
drivers/staging/yaffs2/yaffs_verify.c line 262
Quoted 10 lines
drivers/staging/yaffs2/yaffs_verify.c new file +10
-0+ obj_id, chunk_offset, the_chunk, + tags.obj_id, tags.chunk_id)); + } + } + chunk_offset++; + } + } + } + +return ok;
Here I think it would be nice to reduce the indentation level a bit by by doing something like:
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)
goto out; /* or simply return ok; */
... all the stuff currently inside the if() ...out:
return ok; }
Signature · 3 lines
Jesper Juhl <[email protected]> http://www.chaosbits.net/ Plain text mails only, please http://www.expita.com/nomime.html Don't top-post http://www.catb.org/~esr/jargon/html/T/top-post.html
Re: [PATCH 24/29] Staging: yaffs2: yaffs_verify: Add files
Quoted 18 lines · Jesper Juhl
Quoted 15 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yaffs_verify.c | 631 +++++++++++++++++++++++++++++++++drivers/staging/yaffs2/yaffs_verify.h| 41 +++2 files changed, 672 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yaffs_verify.ccreate mode 100644drivers/staging/yaffs2/yaffs_verify.hdrivers/staging/yaffs2/yaffs_verify.c new file +0
-0...
Quoted 8 lines
Quoted 1 line
+#if 0
Why are you trying to merge new code that's under '#if 0' (and not just here, but elsewhere as well)?
Either it shouldn't be here, in which case it should just be omitted from the patch, or it needs to be here eventually in which case it should be fixed up so the '#if 0' can go away or simply just be added later when it has been fixed up.
You can do all sorts of crazy things under drivers/staging. So no, the code doesn't need to be cleaned up prior to merging. You are, however, correct on what needs to be done for this piece of code to be promoted to mainline proper at some point in time.
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 25/29 Staging: yaffs2: yaffs_vfs_glue.c: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_vfs_glue.c | 3019 +++++++++++++++++++++++++++++++ 1 files changed, 3019 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_vfs_glue.c
drivers/staging/yaffs2/yaffs_vfs_glue.c new file +3019 -0
@@ -0,0 +1,3019 @@ +/* +* 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 <[email protected]> +* Acknowledgements: +* Luc van OostenRyck for numerous patches. +* Nick Bane for numerous patches. +* Nick Bane for 2.5/2.6 integration. +* Andras Toth for mknod rdev issue. +* Michael Fischer for finding the problem with inode inconsistency. +* Some code bodily lifted from JFFS +* +* 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 is the file system front-end to YAFFS that hooks it up to +* the VFS. +* +* Special notes: +* >> 2.4: sb->u.generic_sbp points to the yaffs_dev_t associated with +* this superblock +* >> 2.6: sb->s_fs_info points to the yaffs_dev_t associated with this +* superblock +* >> inode->u.generic_ip points to the associated yaffs_obj_t. +*/ + +/* +* NB There are two variants of Linux VFS glue code. This variant supports +* a single version and should not include any multi-version code. +*/ +#include <linux/version.h> + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/init.h> +#include <linux/fs.h> +#include <linux/proc_fs.h> +#include <linux/smp_lock.h> +#include <linux/pagemap.h> +#include <linux/mtd/mtd.h> +#include <linux/interrupt.h> +#include <linux/string.h> +#include <linux/ctype.h> +#include <linux/namei.h> +#include <linux/exportfs.h> +#include <linux/kthread.h> +#include <linux/delay.h> +#include <linux/freezer.h> + +#include <asm/div64.h> + + +#include <linux/statfs.h> + +#define UnlockPage (p) unlock_page(p) +#define Page_Uptodate (page) test_bit(PG_uptodate, &(page)->flags) + +#define yaffs_devname (sb, buf) bdevname(sb->s_bdev, buf) + +#define YPROC_ROOT NULL + +#define Y_INIT_TIMER (a) init_timer_on_stack(a) + +#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; +} + +#include <linux/uaccess.h> +#include <linux/mtd/mtd.h> + +#include "yportenv.h" +#include "yaffs_trace.h" +#include "yaffs_guts.h" + +#include "yaffs_linux.h" + +#include "yaffs_mtdif.h" +#include "yaffs_mtdif1.h" +#include "yaffs_mtdif2.h" + +unsigned int yaffs_trace_mask =YAFFS_TRACE_BAD_BLOCKS |YAFFS_TRACE_ALWAYS ; +unsigned int yaffs_wr_attempts =YAFFS_WR_ATTEMPTS ; +unsigned int yaffs_auto_checkpoint =1 ; +unsigned int yaffs_gc_control =1 ; +unsigned int yaffs_bg_enable =1 ; + +/* Module Parameters */ +module_param (yaffs_trace_mask, uint,0644 ); +module_param (yaffs_wr_attempts, uint,0644 ); +module_param (yaffs_auto_checkpoint, uint,0644 ); +module_param (yaffs_gc_control, uint,0644 ); +module_param (yaffs_bg_enable, uint,0644 ); + +#define Y_IGET (sb, inum) yaffs_iget((sb), (inum)) + +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_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 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); +static ssize_t yaffs_hold_space (struct file *f); +static void yaffs_release_space (struct file *f); + +static int yaffs_file_flush (struct file *file,fl_owner_t id); + +static int yaffs_sync_object (struct file *file,int datasync); + +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); +static int yaffs_link (struct dentry *old_dentry,struct inode *dir, +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); +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); +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); + +static int yaffs_sync_fs (struct super_block *sb,int wait); +static void yaffs_write_super (struct super_block *sb); + +static int yaffs_statfs (struct dentry *dentry,struct kstatfs *buf); + +#ifdef YAFFS_HAS_PUT_INODE +static void yaffs_put_inode (struct inode *inode); +#endif + +static void yaffs_evict_inode (struct inode *); + +static int yaffs_readpage (struct file *file,struct page *page); +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); +ssize_t yaffs_getxattr (struct dentry *dentry,const char *name,void *buff, +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); +static int yaffs_write_end (struct file *filp,struct address_space *mapping, +loff_t pos,unsigned len,unsigned copied, +struct page *pg,void *fsdadata); + +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 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, + .write_begin = yaffs_write_begin, + .write_end = yaffs_write_end, +}; + + +static const struct file_operations yaffs_file_operations = { + .read = do_sync_read, + .write = do_sync_write, + .aio_read = generic_file_aio_read, + .aio_write = generic_file_aio_write, + .mmap = generic_file_mmap, + .flush = yaffs_file_flush, + .fsync = yaffs_sync_object, + .splice_read = generic_file_splice_read, + .splice_write = generic_file_splice_write, + .llseek = generic_file_llseek, +}; + + + +static const struct inode_operations yaffs_file_inode_operations = { + .setattr = yaffs_setattr, +#ifdef CONFIG_YAFFS_XATTR + .setxattr = yaffs_setxattr, + .getxattr = yaffs_getxattr, + .listxattr = yaffs_listxattr, + .removexattr = yaffs_removexattr, +#endif +}; + +static const struct inode_operations yaffs_symlink_inode_operations = { + .readlink = yaffs_readlink, + .follow_link = yaffs_follow_link, + .put_link = yaffs_put_link, + .setattr = yaffs_setattr, +#ifdef CONFIG_YAFFS_XATTR + .setxattr = yaffs_setxattr, + .getxattr = yaffs_getxattr, + .listxattr = yaffs_listxattr, + .removexattr = yaffs_removexattr, +#endif +}; + +static const struct inode_operations yaffs_dir_inode_operations = { + .create = yaffs_create, + .lookup = yaffs_lookup, + .link = yaffs_link, + .unlink = yaffs_unlink, + .symlink = yaffs_symlink, + .mkdir = yaffs_mkdir, + .rmdir = yaffs_unlink, + .mknod = yaffs_mknod, + .rename = yaffs_rename, + .setattr = yaffs_setattr, +#ifdef CONFIG_YAFFS_XATTR + .setxattr = yaffs_setxattr, + .getxattr = yaffs_getxattr, + .listxattr = yaffs_listxattr, + .removexattr = yaffs_removexattr, +#endif +}; + +static const struct file_operations yaffs_dir_operations = { + .read = generic_read_dir, + .readdir = yaffs_readdir, + .fsync = yaffs_sync_object, + .llseek = yaffs_dir_llseek, +}; + +static const struct super_operations yaffs_super_ops = { + .statfs = yaffs_statfs, +#ifdef YAFFS_HAS_PUT_INODE + .put_inode = yaffs_put_inode, +#endif + .put_super = yaffs_put_super, + .evict_inode = yaffs_evict_inode, + .sync_fs = yaffs_sync_fs, + .write_super = yaffs_write_super, +}; + + +static int yaffs_vfs_setattr (struct inode *inode,struct iattr *attr) +{ +setattr_copy (inode,attr); +return 0 ; +} + +static int yaffs_vfs_setsize (struct inode *inode,loff_t newsize) +{ +truncate_setsize (inode,newsize); +return 0 ; +} + +static unsigned yaffs_gc_control_callback (yaffs_dev_t *dev) +{ +return yaffs_gc_control; +} + +static void yaffs_gross_lock (yaffs_dev_t *dev) +{ +T (YAFFS_TRACE_LOCK , (TSTR ("yaffs locking %p\n" ), current)); +down (&(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) +{ +T (YAFFS_TRACE_LOCK , (TSTR ("yaffs unlocking %p\n" ), current)); +up (&(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) +{ +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) +{ +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) +{ +return generic_fh_to_parent (sb, fid, fh_len, fh_type, yaffs2_nfs_get_inode); +} + +struct dentry *yaffs2_get_parent (struct dentry *dentry) +{ + +struct super_block *sb = dentry->d_inode->i_sb; +struct dentry *parent =ERR_PTR (-ENOENT ); +struct inode *inode; +unsigned long parent_ino; +yaffs_obj_t *d_obj; +yaffs_obj_t *parent_obj; + + d_obj =yaffs_inode_to_obj (dentry->d_inode); + +if (d_obj) { + parent_obj = d_obj->parent; +if (parent_obj) { + parent_ino =yaffs_get_obj_inode (parent_obj); + inode =Y_IGET (sb, parent_ino); + +if (IS_ERR (inode)) { + parent =ERR_CAST (inode); + }else { + parent =d_obtain_alias (inode); +if (!IS_ERR (parent)) { + parent =ERR_PTR (-ENOMEM ); +iput (inode); + } + } + } + } + +return parent; +} + +/* Just declare a zero structure as a NULL value implies +* using the default functions of exportfs. +*/ + +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 +* filldir without causing problems with the directory being modified. +* This is similar to the tried and tested mechanism used in yaffs direct. +* +* A search context iterates along a doubly linked list of siblings in the +* directory. If the iterating object is deleted then this would corrupt +* the list iteration, likely causing a crash. The search context avoids +* this by using the remove_obj_fn to move the search context to the +* 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. +* +* A seach context lives for the duration of a readdir. +* +* All these functions must be called while yaffs is locked. +*/ + +struct yaffs_search_context { +yaffs_dev_t *dev; +yaffs_obj_t *dir_obj; +yaffs_obj_t *next_return; +struct ylist_head others; +}; + +/* +* yaffs_new_search() creates a new search context, initialises it and +* adds it to the device's search context list. +* +* Called at start of readdir. +*/ +static struct yaffs_search_context *yaffs_new_search (yaffs_obj_t *dir) +{ +yaffs_dev_t *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)) + 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)); + } +return sc; +} + +/* +* yaffs_search_end() disposes of a search context and cleans up. +*/ +static void yaffs_search_end (struct yaffs_search_context * sc) +{ +if (sc){ +ylist_del (&sc->others); +YFREE (sc); + } +} + +/* +* yaffs_search_advance() moves a search context to the next object. +* Called when the search iterates or when an object removal causes +* the search context to be moved to the next object. +*/ +static void yaffs_search_advance (struct yaffs_search_context *sc) +{ +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 ( 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); + } +} + +/* +* yaffs_remove_obj_callback() is called when an object is unlinked. +* 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) +{ + +struct ylist_head *i; +struct yaffs_search_context *sc; +struct ylist_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); + } + } + +} + + +/*-----------------------------------------------------------------*/ + +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; + +yaffs_gross_lock (dev); + + alias =yaffs_get_symlink_alias (yaffs_dentry_to_obj (dentry)); + +yaffs_gross_unlock (dev); + +if (!alias) +return -ENOMEM ; + + ret =vfs_readlink (dentry, buffer, buflen, alias); +kfree (alias); +return ret; +} + +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; + +yaffs_gross_lock (dev); + + alias =yaffs_get_symlink_alias (yaffs_dentry_to_obj (dentry)); +yaffs_gross_unlock (dev); + +if (!alias) { + ret =ERR_PTR (-ENOMEM ); + goto out; + } + +nd_set_link (nd, alias); + ret = (void *)alias; +out: +return ret; +} + +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); + +/* +* Lookup is used to find objects in the fs +*/ + +static struct dentry *yaffs_lookup (struct inode *dir,struct dentry *dentry, +struct nameidata *n) +{ +yaffs_obj_t *obj; +struct inode *inode =NULL ;/* NCB 2.5/2.6 needs NULL here */ + +yaffs_dev_t *dev =yaffs_inode_to_obj (dir)->my_dev; + +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)); + + 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) +yaffs_gross_unlock (dev); + +if (obj) { +T (YAFFS_TRACE_OS , + (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 */ +d_add (dentry, inode); + +/* return dentry; */ +return NULL ; +#endif + } + + }else { +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 +* Put inode is called when the inode **structure** is put. +*/ +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))); + +} +#endif + + +static void yaffs_unstitch_obj (struct inode *inode,yaffs_obj_t *obj) +{ +/* Clear the association between the inode and +* the yaffs_obj_t. +*/ + obj->my_inode =NULL ; +yaffs_inode_to_obj_lv (inode) =NULL ; + +/* If the object freeing was deferred, then the real +* free happens now. +* This should fix the inode inconsistency problem. +*/ +yaffs_handle_defered_free (obj); +} + +/* yaffs_evict_inode combines into one operation what was previously done in +* yaffs_clear_inode() and yaffs_delete_inode() +* +*/ +static void yaffs_evict_inode (struct inode *inode) +{ +yaffs_obj_t *obj; +yaffs_dev_t *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" )); + +if (!inode->i_nlink && !is_bad_inode (inode)) + deleteme =1 ; +truncate_inode_pages (&inode->i_data,0 ); +end_writeback (inode); + +if (deleteme && obj){ + dev = obj->my_dev; +yaffs_gross_lock (dev); +yaffs_del_obj (obj); +yaffs_gross_unlock (dev); + } +if (obj) { + dev = obj->my_dev; +yaffs_gross_lock (dev); +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); + +yaffs_dev_t *dev = obj->my_dev; + +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_file_flush object %d (%s)\n" ), obj->obj_id, + obj->dirty ?"dirty" :"clean" )); + +yaffs_gross_lock (dev); + +yaffs_flush_file (obj,1 ,0 ); + +yaffs_gross_unlock (dev); + +return 0 ; +} + +static int yaffs_readpage_nolock (struct file *f,struct page *pg) +{ +/* Lifted from jffs2 */ + +yaffs_obj_t *obj; +unsigned char *pg_buf; +int ret; + +yaffs_dev_t *dev; + +T (YAFFS_TRACE_OS , + (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); + + dev = obj->my_dev; + +BUG_ON (!PageLocked (pg)); + + pg_buf =kmap (pg); +/* FIXME: Can kmap fail? */ + +yaffs_gross_lock (dev); + + ret =yaffs_file_rd (obj, pg_buf, + pg->index <<PAGE_CACHE_SHIFT , +PAGE_CACHE_SIZE ); + +yaffs_gross_unlock (dev); + +if (ret >=0 ) + ret =0 ; + +if (ret) { +ClearPageUptodate (pg); +SetPageError (pg); + }else { +SetPageUptodate (pg); +ClearPageError (pg); + } + +flush_dcache_page (pg); +kunmap (pg); + +T (YAFFS_TRACE_OS , (TSTR ("yaffs_readpage_nolock done\n" ))); +return ret; +} + +static int yaffs_readpage_unlock (struct file *f,struct page *pg) +{ +int ret =yaffs_readpage_nolock (f, pg); +UnlockPage (pg); +return ret; +} + +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); +T (YAFFS_TRACE_OS , (TSTR ("yaffs_readpage done\n" ))); +return ret; +} + +/* writepage inspired by/stolen from smbfs */ + +static int yaffs_writepage (struct page *page,struct writeback_control *wbc) +{ +yaffs_dev_t *dev; +struct address_space *mapping = page->mapping; +struct inode *inode; +unsigned long end_index; +char *buffer; +yaffs_obj_t *obj; +int n_written =0 ; +unsigned n_bytes; +loff_t i_size; + +if (!mapping) +BUG (); + inode = mapping->host; +if (!inode) +BUG (); + i_size =i_size_read (inode); + + end_index = i_size >>PAGE_CACHE_SHIFT ; + +if (page->index < end_index) + n_bytes =PAGE_CACHE_SIZE ; +else { + 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)); +T (YAFFS_TRACE_OS , + (TSTR (" -> don't care!!\n" ))); + +zero_user_segment (page,0 ,PAGE_CACHE_SIZE ); +set_page_writeback (page); +unlock_page (page); +end_page_writeback (page); +return 0 ; + } + } + +if (n_bytes !=PAGE_CACHE_SIZE ) +zero_user_segment (page,n_bytes,PAGE_CACHE_SIZE ); + +get_page (page); + + buffer =kmap (page); + + obj =yaffs_inode_to_obj (inode); + dev = obj->my_dev; +yaffs_gross_lock (dev); + +T (YAFFS_TRACE_OS , + (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)); + + n_written =yaffs_wr_file (obj, buffer, + 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)); + +yaffs_gross_unlock (dev); + +kunmap (page); +set_page_writeback (page); +unlock_page (page); +end_page_writeback (page); +put_page (page); + +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) +{ +struct page *pg =NULL ; +pgoff_t index = pos >>PAGE_CACHE_SHIFT ; + +int ret =0 ; +int space_held =0 ; + +/* Get a page */ + pg =grab_cache_page_write_begin (mapping, index, flags); + + *pagep = pg; +if (!pg) { + 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 )); + +/* Get fs space */ + space_held =yaffs_hold_space (filp); + +if (!space_held) { + ret = -ENOSPC ; + goto out; + } + +/* Update page if required */ + +if (!Page_Uptodate (pg)) + ret =yaffs_readpage_nolock (filp, pg); + +if (ret) + goto out; + +/* Happy path return */ +T (YAFFS_TRACE_OS , (TSTR ("end yaffs_write_begin - ok\n" ))); + +return 0 ; + +out: +T (YAFFS_TRACE_OS , + (TSTR ("end yaffs_write_begin fail returning %d\n" ), ret)); +if (space_held) +yaffs_release_space (filp); +if (pg) { +unlock_page (pg); +page_cache_release (pg); + } +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) +{ +int ret =0 ; +void *addr, *kva; +uint32_t offset_into_page = pos & (PAGE_CACHE_SIZE -1 ); + + kva =kmap (pg); + addr = kva + offset_into_page; + +T (YAFFS_TRACE_OS , + ("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)); +SetPageError (pg); + }else { +/* Nothing */ + } + +kunmap (pg); + +yaffs_release_space (filp); +unlock_page (pg); +page_cache_release (pg); +return ret; +} + + +static void yaffs_fill_inode_from_obj (struct inode *inode,yaffs_obj_t *obj) +{ +if (inode && obj) { + + +/* Check mode against the variant type and attempt to repair if broken. */ +__u32 mode = obj->yst_mode; +switch (obj->variant_type) { +case YAFFS_OBJECT_TYPE_FILE : +if (!S_ISREG (mode)) { + obj->yst_mode &= ~S_IFMT ; + obj->yst_mode |=S_IFREG ; + } + +break ; +case YAFFS_OBJECT_TYPE_SYMLINK : +if (!S_ISLNK (mode)) { + obj->yst_mode &= ~S_IFMT ; + obj->yst_mode |=S_IFLNK ; + } + +break ; +case YAFFS_OBJECT_TYPE_DIRECTORY : +if (!S_ISDIR (mode)) { + obj->yst_mode &= ~S_IFMT ; + obj->yst_mode |=S_IFDIR ; + } + +break ; +case YAFFS_OBJECT_TYPE_UNKNOWN : +case YAFFS_OBJECT_TYPE_HARDLINK : +case YAFFS_OBJECT_TYPE_SPECIAL : +default : +/* TODO? */ +break ; + } + + inode->i_flags |=S_NOATIME ; + + inode->i_ino = obj->obj_id; + inode->i_mode = obj->yst_mode; + inode->i_uid = obj->yst_uid; + inode->i_gid = obj->yst_gid; + + inode->i_rdev =old_decode_dev (obj->yst_rdev); + + inode->i_atime.tv_sec = (time_t) (obj->yst_atime); + inode->i_atime.tv_nsec =0 ; + inode->i_mtime.tv_sec = (time_t ) obj->yst_mtime; + inode->i_mtime.tv_nsec =0 ; + inode->i_ctime.tv_sec = (time_t ) obj->yst_ctime; + inode->i_ctime.tv_nsec =0 ; + inode->i_size =yaffs_get_obj_length (obj); + inode->i_blocks = (inode->i_size +511 ) >>9 ; + + 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))); + +switch (obj->yst_mode &S_IFMT ) { +default :/* fifo, device or socket */ +init_special_inode (inode, obj->yst_mode, +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; +break ; +case S_IFDIR :/* directory */ + inode->i_op = &yaffs_dir_inode_operations; + inode->i_fop = &yaffs_dir_operations; +break ; +case S_IFLNK :/* symlink */ + inode->i_op = &yaffs_symlink_inode_operations; +break ; + } + +yaffs_inode_to_obj_lv (inode) = obj; + + obj->my_inode = inode; + + }else { +T (YAFFS_TRACE_OS , + (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 inode *inode; + +if (!sb) { +T (YAFFS_TRACE_OS , + (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" ))); +return NULL ; + + } + +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_get_inode for object %d\n" ), obj->obj_id)); + + inode =Y_IGET (sb, obj->obj_id); +if (IS_ERR (inode)) +return NULL ; + +/* NB Side effect: iget calls back to yaffs_read_inode(). */ +/* iget also increments the inode's i_count */ +/* NB You can't be holding gross_lock or deadlock will happen! */ + +return inode; +} + +static ssize_t yaffs_file_write (struct file *f,const char *buf,size_t n, +loff_t *pos) +{ +yaffs_obj_t *obj; +int n_written, ipos; +struct inode *inode; +yaffs_dev_t *dev; + + obj =yaffs_dentry_to_obj (f->f_dentry); + + dev = obj->my_dev; + +yaffs_gross_lock (dev); + + inode = f->f_dentry->d_inode; + +if (!S_ISBLK (inode->i_mode) && f->f_flags &O_APPEND ) + ipos = inode->i_size; +else + ipos = *pos; + +if (!obj) +T (YAFFS_TRACE_OS , + (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" +"to object %d at %d(%x)\n" ), + (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)); + +if (n_written >0 ) { + ipos += n_written; + *pos = ipos; +if (ipos > inode->i_size) { + inode->i_size = ipos; + 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))); + } + + } +yaffs_gross_unlock (dev); +return (n_written ==0 ) && (n >0 ) ? -ENOSPC : n_written; +} + +/* Space holding and freeing is done to ensure we have space available for write_begin/end */ +/* For now we just assume few parallel writes and check against a small number. */ +/* Todo: need to do this with a counter to handle parallel reads better */ + +static ssize_t yaffs_hold_space (struct file *f) +{ +yaffs_obj_t *obj; +yaffs_dev_t *dev; + +int n_free_chunks; + + + obj =yaffs_dentry_to_obj (f->f_dentry); + + dev = obj->my_dev; + +yaffs_gross_lock (dev); + + n_free_chunks =yaffs_get_n_free_chunks (dev); + +yaffs_gross_unlock (dev); + +return (n_free_chunks >20 ) ?1 :0 ; +} + +static void yaffs_release_space (struct file *f) +{ +yaffs_obj_t *obj; +yaffs_dev_t *dev; + + + obj =yaffs_dentry_to_obj (f->f_dentry); + + dev = obj->my_dev; + +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){ +case 2 : + offset +=i_size_read (file->f_path.dentry->d_inode); +break ; +case 1 : + offset += file->f_pos; + } + retval = -EINVAL ; + +if (offset >=0 ){ +if (offset != file->f_pos) + file->f_pos = offset; + + retval = offset; + } +unlock_kernel (); +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 inode *inode = f->f_dentry->d_inode; +unsigned long offset, curoffs; +yaffs_obj_t *l; +int ret_val =0 ; + +char name[YAFFS_MAX_NAME_LENGTH +1 ]; + + obj =yaffs_dentry_to_obj (f->f_dentry); + dev = obj->my_dev; + +yaffs_gross_lock (dev); + +yaffs_dev_to_lc (dev)->readdir_process = current; + + offset = f->f_pos; + + 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)); + +if (offset ==0 ) { +T (YAFFS_TRACE_OS , + (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 ){ +yaffs_gross_lock (dev); + goto out; + } +yaffs_gross_lock (dev); + offset++; + f->f_pos++; + } +if (offset ==1 ) { +T (YAFFS_TRACE_OS , + (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 ){ +yaffs_gross_lock (dev); + goto out; + } +yaffs_gross_lock (dev); + offset++; + f->f_pos++; + } + + curoffs =1 ; + +/* If the directory has changed since the open or last call to +readdir, rewind to after the 2 canned entries. */ +if (f->f_version != inode->i_version) { + offset =2 ; + f->f_pos = offset; + f->f_version = inode->i_version; + } + +while (sc->next_return){ + curoffs++; + l = sc->next_return; +if (curoffs >= offset) { +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 ); +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_readdir: %s inode %d\n" ), + name,yaffs_get_obj_inode (l))); + +yaffs_gross_unlock (dev); + +if (filldir (dirent, + name, +strlen (name), + offset, + this_inode, + this_type) <0 ){ +yaffs_gross_lock (dev); + goto out; + } + +yaffs_gross_lock (dev); + + offset++; + f->f_pos++; + } +yaffs_search_advance (sc); + } + +out: +yaffs_search_end (sc); +yaffs_dev_to_lc (dev)->readdir_process =NULL ; +yaffs_gross_unlock (dev); + +return ret_val; +} + + + +/* +* File creation. Allocate an inode, and we're done.. +*/ + +#define YCRED (x) (x->cred) + +static int yaffs_mknod (struct inode *dir,struct dentry *dentry,int mode, +dev_t rdev) +{ +struct inode *inode; + +yaffs_obj_t *obj =NULL ; +yaffs_dev_t *dev; + +yaffs_obj_t *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; + +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)); + }else { +T (YAFFS_TRACE_OS , + (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)); + + dev = parent->my_dev; + +yaffs_gross_lock (dev); + +switch (mode &S_IFMT ) { +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)); +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); +break ; +case S_IFDIR :/* directory */ +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_mknod: making directory\n" ))); + obj =yaffs_create_dir (parent, dentry->d_name.name, mode, + uid, gid); +break ; +case S_IFLNK :/* symlink */ +T (YAFFS_TRACE_OS , (TSTR ("yaffs_mknod: making symlink\n" ))); + obj =NULL ;/* Do we ever get here? */ +break ; + } + +/* Can not call yaffs_get_inode() with gross lock held */ +yaffs_gross_unlock (dev); + +if (obj) { + inode =yaffs_get_inode (dir->i_sb, mode, rdev, obj); +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))); + error =0 ; +yaffs_fill_inode_from_obj (dir,parent); + }else { +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_mknod failed making object\n" ))); + error = -ENOMEM ; + } + +return error; +} + +static int yaffs_mkdir (struct inode *dir,struct dentry *dentry,int mode) +{ +int ret_val; +T (YAFFS_TRACE_OS , (TSTR ("yaffs_mkdir\n" ))); + ret_val =yaffs_mknod (dir, dentry, mode |S_IFDIR ,0 ); +return ret_val; +} + +static int yaffs_create (struct inode *dir,struct dentry *dentry,int mode, +struct nameidata *n) +{ +T (YAFFS_TRACE_OS ,(TSTR ("yaffs_create\n" ))); +return yaffs_mknod (dir, dentry, mode |S_IFREG ,0 ); +} + +static int yaffs_unlink (struct inode *dir,struct dentry *dentry) +{ +int ret_val; + +yaffs_dev_t *dev; +yaffs_obj_t *obj; + +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_unlink %d:%s\n" ), + (int )(dir->i_ino), + dentry->d_name.name)); + obj =yaffs_inode_to_obj (dir); + dev = obj->my_dev; + +yaffs_gross_lock (dev); + + ret_val =yaffs_unlinker (obj, dentry->d_name.name); + +if (ret_val ==YAFFS_OK ) { + dentry->d_inode->i_nlink--; + dir->i_version++; +yaffs_gross_unlock (dev); +mark_inode_dirty (dentry->d_inode); +update_dir_time (dir); +return 0 ; + } +yaffs_gross_unlock (dev); +return -ENOTEMPTY ; +} + +/* +* Create a link... +*/ +static int yaffs_link (struct dentry *old_dentry,struct inode *dir, +struct dentry *dentry) +{ +struct inode *inode = old_dentry->d_inode; +yaffs_obj_t *obj =NULL ; +yaffs_obj_t *link =NULL ; +yaffs_dev_t *dev; + +T (YAFFS_TRACE_OS , (TSTR ("yaffs_link\n" ))); + + obj =yaffs_inode_to_obj (inode); + dev = obj->my_dev; + +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 (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))); + } + +yaffs_gross_unlock (dev); + +if (link){ +update_dir_time (dir); +return 0 ; + } + +return -EPERM ; +} + +static int yaffs_symlink (struct inode *dir,struct dentry *dentry, +const char *symname) +{ +yaffs_obj_t *obj; +yaffs_dev_t *dev; +uid_t uid =YCRED (current)->fsuid; +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); +yaffs_gross_unlock (dev); + +if (obj) { +struct inode *inode; + + inode =yaffs_get_inode (dir->i_sb, obj->yst_mode,0 , obj); +d_instantiate (dentry, inode); +update_dir_time (dir); +T (YAFFS_TRACE_OS , (TSTR ("symlink created OK\n" ))); +return 0 ; + }else { +T (YAFFS_TRACE_OS , (TSTR ("symlink not created\n" ))); + } + +return -ENOMEM ; +} + +static int yaffs_sync_object (struct file *file,int datasync) +{ + +yaffs_obj_t *obj; +yaffs_dev_t *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" ))); +yaffs_gross_lock (dev); +yaffs_flush_file (obj,1 , datasync); +yaffs_gross_unlock (dev); +return 0 ; +} + +/* +* The VFS layer already does all the dentry stuff for rename. +* +* NB: POSIX says you can rename an object over an old object of the same name +*/ +static int yaffs_rename (struct inode *old_dir,struct dentry *old_dentry, +struct inode *new_dir,struct dentry *new_dentry) +{ +yaffs_dev_t *dev; +int ret_val =YAFFS_FAIL ; +yaffs_obj_t *target; + +T (YAFFS_TRACE_OS , (TSTR ("yaffs_rename\n" ))); + dev =yaffs_inode_to_obj (old_dir)->my_dev; + +yaffs_gross_lock (dev); + +/* 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); + + + +if (target && target->variant_type ==YAFFS_OBJECT_TYPE_DIRECTORY && + !ylist_empty (&target->variant.dir_variant.children)) { + +T (YAFFS_TRACE_OS , (TSTR ("target is non-empty dir\n" ))); + + ret_val =YAFFS_FAIL ; + }else { +/* Now does unlinking internally using shadowing mechanism */ +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); + } +yaffs_gross_unlock (dev); + +if (ret_val ==YAFFS_OK ) { +if (target) { + new_dentry->d_inode->i_nlink--; +mark_inode_dirty (new_dentry->d_inode); + } + +update_dir_time (old_dir); +if (old_dir != new_dir) +update_dir_time (new_dir); +return 0 ; + }else { +return -ENOTEMPTY ; + } +} + +static int yaffs_setattr (struct dentry *dentry,struct iattr *attr) +{ +struct inode *inode = dentry->d_inode; +int error =0 ; +yaffs_dev_t *dev; + +T (YAFFS_TRACE_OS , + (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 )) + error = -EINVAL ; + +if (error ==0 ) + error =inode_change_ok (inode, attr); +if (error ==0 ) { +int result; +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 ; + } + } + 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))); + } +yaffs_gross_lock (dev); + result =yaffs_set_attribs (yaffs_inode_to_obj (inode), attr); +if (result ==YAFFS_OK ) { + error =0 ; + }else { + error = -EPERM ; + } +yaffs_gross_unlock (dev); + + } + +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) +{ +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)); + + +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 ) + error =0 ; +else if (result <0 ) + error = result; +yaffs_gross_unlock (dev); + + } +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) +{ +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_getxattr \"%s\" from object %d\n" ), + name, obj->obj_id)); + +if (error ==0 ) { + dev = obj->my_dev; +yaffs_gross_lock (dev); + error =yaffs_get_xattrib (obj, name, buff, size); +yaffs_gross_unlock (dev); + + } +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_getxattr done returning %d\n" ),error)); + +return error; +} + +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); + +T (YAFFS_TRACE_OS , + (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 ) + error =0 ; +else if (result <0 ) + error = result; +yaffs_gross_unlock (dev); + + } +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_removexattr done returning %d\n" ),error)); + +return error; +} + +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); + +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_listxattr of object %d\n" ), + obj->obj_id)); + + +if (error ==0 ) { + dev = obj->my_dev; +yaffs_gross_lock (dev); + error =yaffs_list_xattrib (obj, buff, size); +yaffs_gross_unlock (dev); + + } +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 super_block *sb = dentry->d_sb; + +T (YAFFS_TRACE_OS , (TSTR ("yaffs_statfs\n" ))); + +yaffs_gross_lock (dev); + + buf->f_type =YAFFS_MAGIC ; + buf->f_bsize = sb->s_blocksize; + buf->f_namelen =255 ; + +if (dev->data_bytes_per_chunk & (dev->data_bytes_per_chunk -1 )) { +/* Do this if chunk size is not a power of 2 */ + +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)); + +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)); + +do_div (bytes_free, sb->s_blocksize); + + buf->f_bfree = bytes_free; + + }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); + buf->f_bfree = +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); + + buf->f_bfree = +yaffs_get_n_free_chunks (dev) * + (dev->data_bytes_per_chunk / sb->s_blocksize); + } + + buf->f_files =0 ; + buf->f_ffree =0 ; + buf->f_bavail = buf->f_bfree; + +yaffs_gross_unlock (dev); +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){ + obj =yaffs_inode_to_obj (iptr); +if (obj){ +T (YAFFS_TRACE_OS , (TSTR ("flushing obj %d\n" ), + 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) +return ; + +yaffs_flush_inodes (sb); +yaffs_update_dirty_dirs (dev); +yaffs_flush_whole_cache (dev); +if (do_checkpoint) +yaffs_checkpoint_save (dev); +} + + +static unsigned yaffs_bg_gc_urgency (yaffs_dev_t *dev) +{ +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 */ + +if (erased_chunks < dev->n_free_chunks) + scattered = (dev->n_free_chunks - erased_chunks); + +if (!context->bg_running) +return 0 ; +else if (scattered < (dev->param.chunks_per_block *2 )) +return 0 ; +else if (erased_chunks > dev->n_free_chunks/2 ) +return 0 ; +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) +{ + +yaffs_dev_t *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" :"" )); + +yaffs_gross_lock (dev); + do_checkpoint = ((request_checkpoint && !gc_urgent) || + 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) + yaffs_auto_checkpoint &= ~4 ; + } +yaffs_gross_unlock (dev); + +return 0 ; +} + +/* +* yaffs background thread functions . +* yaffs_bg_thread_fn() the thread function +* yaffs_bg_start() launches the background thread. +* yaffs_bg_stop() cleans up the background thread. +* +* NB: +* The thread should only run after the yaffs is initialised +* The thread should be stopped before yaffs is unmounted. +* 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); +} + +static int yaffs_bg_thread_fn (void *data) +{ +yaffs_dev_t *dev = (yaffs_dev_t *)data; +struct yaffs_linux_context *context =yaffs_dev_to_lc (dev); +unsigned long now = jiffies; +unsigned long next_dir_update = now; +unsigned long next_gc = now; +unsigned long expires; +unsigned int urgency; + +int gc_result; +struct timer_list timer; + +T (YAFFS_TRACE_BACKGROUND , + (TSTR ("yaffs_background starting for dev %p\n" ), + (void *)dev)); + +set_freezable (); +while (context->bg_running){ +T (YAFFS_TRACE_BACKGROUND , + (TSTR ("yaffs_background\n" ))); + +if (kthread_should_stop ()) +break ; + +if (try_to_freeze ()) +continue ; + +yaffs_gross_lock (dev); + + now = jiffies; + +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){ + 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 ; +else + next_gc = now +HZ *2 ; + }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)) + expires = next_gc; +if (time_before (expires,now)) + expires = now +HZ ; + +Y_INIT_TIMER (&timer); + timer.expires = expires+1 ; + timer.data = (unsigned long ) current; + timer.function = yaffs_background_waker; + +set_current_state (TASK_INTERRUPTIBLE ); +add_timer (&timer); +schedule (); +del_timer_sync (&timer); + } + +return 0 ; +} + +static int yaffs_bg_start (yaffs_dev_t *dev) +{ +int retval =0 ; +struct yaffs_linux_context *context =yaffs_dev_to_lc (dev); + +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); + +if (IS_ERR (context->bg_thread)){ + retval =PTR_ERR (context->bg_thread); + context->bg_thread =NULL ; + context->bg_running =0 ; + } +return retval; +} + +static void yaffs_bg_stop (yaffs_dev_t *dev) +{ +struct yaffs_linux_context *ctxt =yaffs_dev_to_lc (dev); + + ctxt->bg_running =0 ; + +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" :"" )); + +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" :"" )); + +yaffs_do_sync_fs (sb, request_checkpoint); + +return 0 ; +} + +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); + +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_iget for %lu\n" ), ino)); + + inode =iget_locked (sb, ino); +if (!inode) +return ERR_PTR (-ENOMEM ); +if (!(inode->i_state &I_NEW )) +return inode; + +/* NB This is called as a side effect of other functions, but +* we had to release the lock to prevent deadlocks, so +* need to lock again. +*/ + +yaffs_gross_lock (dev); + + obj =yaffs_find_by_number (dev, inode->i_ino); + +yaffs_fill_inode_from_obj (inode, obj); + +yaffs_gross_unlock (dev); + +unlock_new_inode (inode); +return inode; +} + +static YLIST_HEAD (yaffs_context_list); +struct semaphore yaffs_context_lock; + +static void yaffs_put_super (struct super_block *sb) +{ +yaffs_dev_t *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" ))); +yaffs_bg_stop (dev); +T (YAFFS_TRACE_OS |YAFFS_TRACE_BACKGROUND , + (TSTR ("yaffs background thread shut down\n" ))); + +yaffs_gross_lock (dev); + +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); + +if (yaffs_dev_to_lc (dev)->spare_buffer) { +YFREE (yaffs_dev_to_lc (dev)->spare_buffer); +yaffs_dev_to_lc (dev)->spare_buffer =NULL ; + } + +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)); + +if (mtd->sync) + mtd->sync (mtd); + +put_mtd_device (mtd); +} + + +static void yaffs_touch_super (yaffs_dev_t *dev) +{ +struct super_block *sb =yaffs_dev_to_lc (dev)->super; + +T (YAFFS_TRACE_OS , (TSTR ("yaffs_touch_super() sb = %p\n" ), sb)); +if (sb) + sb->s_dirt =1 ; +} + +typedef struct { +int inband_tags; +int skip_checkpoint_read; +int skip_checkpoint_write; +int no_cache; +int tags_ecc_on; +int tags_ecc_overridden; +int lazy_loading_enabled; +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) +{ +char cur_opt[MAX_OPT_LEN +1 ]; +int p; +int error =0 ; + +/* Parse through the options which is a comma seperated list */ + +while (options_str && *options_str && !error) { +memset (cur_opt,0 ,MAX_OPT_LEN +1 ); + p =0 ; + +while (*options_str ==',' ) + options_str++; + +while (*options_str && *options_str !=',' ) { +if (p <MAX_OPT_LEN ) { + cur_opt[p] = *options_str; + p++; + } + options_str++; + } + +if (!strcmp (cur_opt,"inband-tags" )) + options->inband_tags =1 ; +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_on =1 ; + options->tags_ecc_overridden =1 ; + }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_enabled =1 ; + options->lazy_loading_overridden =1 ; + }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 =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" )) + options->skip_checkpoint_read =1 ; +else if (!strcmp (cur_opt,"no-checkpoint-write" )) + options->skip_checkpoint_write =1 ; +else if (!strcmp (cur_opt,"no-checkpoint" )) { + options->skip_checkpoint_read =1 ; + options->skip_checkpoint_write =1 ; + }else { +printk (KERN_INFO "yaffs: Bad mount option \"%s\"\n" , + cur_opt); + error =1 ; + } + } + +return error; +} + +static struct super_block *yaffs_internal_read_super (int yaffs_version, +struct super_block *sb, +void *data,int silent) +{ +int nBlocks; +struct inode *inode =NULL ; +struct dentry *root; +yaffs_dev_t *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; + +int read_only =0 ; + +yaffs_options options; + +unsigned mount_id; +int found; +struct yaffs_linux_context *context_iterator; +struct ylist_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 ); + + sb->s_export_op = &yaffs_export_ops; + +if (!sb) +printk (KERN_INFO "yaffs: sb is NULL\n" ); +else if (!sb->s_dev) +printk (KERN_INFO "yaffs: sb->s_dev is NULL\n" ); +else if (!yaffs_devname (sb, devname_buf)) +printk (KERN_INFO "yaffs: devname is NULL\n" ); +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" ); + +if (!data_str) + data_str ="" ; + +printk (KERN_INFO "yaffs: passed flags \"%s\"\n" , data_str); + +memset (&options,0 ,sizeof (options)); + +if (yaffs_parse_options (&options, data_str)) { +/* Option parsing failed */ +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)); +T (YAFFS_TRACE_OS , + (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))); + +/* Check it's an mtd device..... */ +if (MAJOR (sb->s_dev) !=MTD_BLOCK_MAJOR ) +return NULL ;/* This isn't an mtd device */ + +/* Get the device */ + 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))); +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)); +return NULL ; + } + +T (YAFFS_TRACE_OS , (TSTR (" erase %p\n" ), mtd->erase)); +T (YAFFS_TRACE_OS , (TSTR (" read %p\n" ), mtd->read)); +T (YAFFS_TRACE_OS , (TSTR (" write %p\n" ), mtd->write)); +T (YAFFS_TRACE_OS , (TSTR (" readoob %p\n" ), mtd->read_oob)); +T (YAFFS_TRACE_OS , (TSTR (" writeoob %p\n" ), mtd->write_oob)); +T (YAFFS_TRACE_OS , (TSTR (" block_isbad %p\n" ), mtd->block_isbad)); +T (YAFFS_TRACE_OS , (TSTR (" block_markbad %p\n" ), mtd->block_markbad)); +T (YAFFS_TRACE_OS , (TSTR (" %s %d\n" ),WRITE_SIZE_STR ,WRITE_SIZE (mtd))); +T (YAFFS_TRACE_OS , (TSTR (" oobsize %d\n" ), mtd->oobsize)); +T (YAFFS_TRACE_OS , (TSTR (" erasesize %d\n" ), mtd->erasesize)); +T (YAFFS_TRACE_OS , (TSTR (" size %lld\n" ), mtd->size)); + +#ifdef CONFIG_YAFFS_AUTO_YAFFS2 + +if (yaffs_version ==1 &&WRITE_SIZE (mtd) >=2048 ) { +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" ))); + 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->read_oob || !mtd->write_oob) { +T (YAFFS_TRACE_ALWAYS , + (TSTR ("yaffs: MTD device does not support required " +"functions\n" ))); +return NULL ; + } + +if ((WRITE_SIZE (mtd) <YAFFS_MIN_YAFFS2_CHUNK_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" ))); +return NULL ; + } + }else { +/* Check for V1 style functions */ +if (!mtd->erase || + !mtd->read || + !mtd->write || + !mtd->read_oob || !mtd->write_oob) { +T (YAFFS_TRACE_ALWAYS , + (TSTR ("yaffs: MTD device does not support required " +"functions\n" ))); +return NULL ; + } + +if (WRITE_SIZE (mtd) <YAFFS_BYTES_PER_CHUNK || + mtd->oobsize !=YAFFS_BYTES_PER_SPARE ) { +T (YAFFS_TRACE_ALWAYS , + (TSTR ("yaffs: MTD device does not support have the " +"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 +*/ + +if (!read_only && !(mtd->flags &MTD_WRITEABLE )){ + read_only =1 ; +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) +kfree (dev); +if (context) +kfree (context); + dev =NULL ; + context =NULL ; + } + +if (!dev) { +/* Deep shit could not allocate device structure */ +T (YAFFS_TRACE_ALWAYS , + (TSTR ("yaffs_read_super: Failed trying to allocate " +"yaffs_dev_t. \n" ))); +return NULL ; + } +memset (dev,0 ,sizeof (yaffs_dev_t)); + param = &(dev->param); + +memset (context,0 ,sizeof (struct yaffs_linux_context )); + dev->os_context = context; +YINIT_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 )); + + param->start_block =0 ; + param->end_block = nBlocks -1 ; + param->chunks_per_block =YAFFS_CHUNKS_PER_BLOCK ; + param->total_bytes_per_chunk =YAFFS_BYTES_PER_CHUNK ; + param->n_reserved_blocks =5 ; + param->n_caches = (options.no_cache) ?0 :10 ; + param->inband_tags = options.inband_tags; + +#ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD + param->disable_lazy_load =1 ; +#endif +#ifdef CONFIG_YAFFS_XATTR + param->enable_xattr =1 ; +#endif +if (options.lazy_loading_overridden) + param->disable_lazy_load = !options.lazy_loading_enabled; + +#ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC + param->no_tags_ecc =1 ; +#endif + +#ifdef CONFIG_YAFFS_DISABLE_BACKGROUND +#else + param->defered_dir_update =1 ; +#endif + +if (options.tags_ecc_overridden) + param->no_tags_ecc = !options.tags_ecc_on; + +#ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND + param->empty_lost_n_found =1 ; +#endif + +#ifdef CONFIG_YAFFS_DISABLE_BLOCK_REFRESHING + param->refresh_period =0 ; +#else + param->refresh_period =500 ; +#endif + +#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED + param->always_check_erased =1 ; +#endif + +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->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); + + param->start_block =0 ; + param->end_block = nBlocks -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->bad_block_fn = nandmtd1_mark_block_bad; + param->query_block_fn = nandmtd1_query_block; + param->is_yaffs2 =0 ; + } +/* ... and common functions */ + param->erase_fn = nandmtd_erase_block; + param->initialise_flash_fn = nandmtd_initialise; + +yaffs_dev_to_lc (dev)->put_super_fn = yaffs_mtd_put_super; + + param->sb_dirty_fn = yaffs_touch_super; + param->gc_control = yaffs_gc_control_callback; + +yaffs_dev_to_lc (dev)->super= sb; + + +#ifndef CONFIG_YAFFS_DOES_ECC + param->use_nand_ecc =1 ; +#endif + +#ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES + param->wide_tnodes_disabled =1 ; +#endif + + param->skip_checkpt_rd = options.skip_checkpoint_read; + param->skip_checkpt_wr = options.skip_checkpoint_write; + +down (&yaffs_context_lock); +/* Get a mount id */ + found =0 ; +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) + found =0 ; + } + } + context->mount_id = mount_id; + +ylist_add_tail (&(yaffs_dev_to_lc (dev)->context_list), &yaffs_context_list); +up (&yaffs_context_lock); + +/* Directory search handling...*/ +YINIT_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)); + +yaffs_gross_lock (dev); + + err =yaffs_guts_initialise (dev); + +T (YAFFS_TRACE_OS , + (TSTR ("yaffs_read_super: guts initialised %s\n" ), + (err ==YAFFS_OK ) ?"OK" :"FAILED" )); + +if (err ==YAFFS_OK ) +yaffs_bg_start (dev); + +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)); + +if (!inode) +return NULL ; + + inode->i_op = &yaffs_dir_inode_operations; + inode->i_fop = &yaffs_dir_operations; + +T (YAFFS_TRACE_OS , (TSTR ("yaffs_read_super: got root inode\n" ))); + + root =d_alloc_root (inode); + +T (YAFFS_TRACE_OS , (TSTR ("yaffs_read_super: d_alloc_root done\n" ))); + +if (!root) { +iput (inode); +return NULL ; + } + 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)); + +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) +{ +return yaffs_internal_read_super (1 , sb, data, silent) ?0 : -EINVAL ; +} + +static int yaffs_read_super (struct file_system_type *fs, +int flags,const char *dev_name, +void *data,struct vfsmount *mnt) +{ + +return get_sb_bdev (fs, flags, dev_name, data, + yaffs_internal_read_super_mtd, mnt); +} + +static struct file_system_type yaffs_fs_type = { + .owner =THIS_MODULE , + .name ="yaffs" , + .get_sb = yaffs_read_super, + .kill_sb = kill_block_super, + .fs_flags =FS_REQUIRES_DEV , +}; + + +#ifdef CONFIG_YAFFS_YAFFS2 + +static int yaffs2_internal_read_super_mtd (struct super_block *sb,void *data, +int silent) +{ +return yaffs_internal_read_super (2 , sb, data, silent) ?0 : -EINVAL ; +} + +static int yaffs2_read_super (struct file_system_type *fs, +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); +} + +static struct file_system_type yaffs2_fs_type = { + .owner =THIS_MODULE , + .name ="yaffs2" , + .get_sb = yaffs2_read_super, + .kill_sb = kill_block_super, + .fs_flags =FS_REQUIRES_DEV , +}; +#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); + 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" ); + +return buf; +} + + +static char *yaffs_dump_dev_part1 (char *buf,yaffs_dev_t * dev) +{ + 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" ); + buf +=sprintf (buf,"n_tnodes.............. %d\n" , dev->n_tnodes); + buf +=sprintf (buf,"n_obj................. %d\n" , dev->n_obj); + buf +=sprintf (buf,"n_free_chunks......... %d\n" , dev->n_free_chunks); + buf +=sprintf (buf,"\n" ); + buf +=sprintf (buf,"n_page_writes......... %u\n" , dev->n_page_writes); + buf +=sprintf (buf,"n_page_reads.......... %u\n" , dev->n_page_reads); + 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,"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_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,"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,"refresh_count......... %u\n" , dev->refresh_count); + buf +=sprintf (buf,"n_bg_deletions........ %u\n" , dev->n_bg_deletions); + +return buf; +} + +static int yaffs_proc_read (char *page, +char **start, +off_t offset,int count,int *eof,void *data) +{ +struct ylist_head *item; +char *buf = page; +int step = offset; +int n =0 ; + +/* Get proc_file_read() to step 'offset' by one on each sucessive call. +* We use 'offset' (*ppos) to indicate where we are in dev_list. +* This also assumes the user has posted a read buffer large +* enough to hold the complete output; but that's life in /proc. +*/ + + *(int *)start =1 ; + +/* Print header first */ +if (step ==0 ) + buf +=sprintf (buf,"YAFFS built:" __DATE__" " __TIME__"\n" ); +else if (step ==1 ) + buf +=sprintf (buf,"\n" ); +else { + step-=2 ; + +down (&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; + +if (n < (step & ~1 )) { + n+=2 ; +continue ; + } +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); + } + +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) +{ +struct ylist_head *item; +char *buf = page; +int n =0 ; + +down (&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; + +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); + + +return buf - page < count ? buf - page : count; +} + +/** +* Set the verbosity of the warnings and error messages. +* +* Note that the names can only be a..z or _ with the current code. +*/ + +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 }, +}; + +#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 rg =0 , mask_bitfield; +char *end; +char *mask_name; +const char *x; +char substring[MAX_MASK_NAME_LENGTH +1 ]; +int i; +int done =0 ; +int add, len =0 ; +int pos =0 ; + + rg = yaffs_trace_mask; + +while (!done && (pos < count)) { + done =1 ; +while ((pos < count) &&isspace (buf[pos])) + pos++; + +switch (buf[pos]) { +case '+' : +case '-' : +case '=' : + add = buf[pos]; + pos++; +break ; + +default : + add =' ' ; +break ; + } + mask_name =NULL ; + + mask_bitfield =simple_strtoul (buf + pos, &end,0 ); + +if (end > buf + pos) { + mask_name ="numeral" ; + len = end - (buf + pos); + pos += len; + done =0 ; + }else { +for (x = buf + pos, i =0 ; + (*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 ) { + mask_name = mask_flags[i].mask_name; + mask_bitfield = mask_flags[i].mask_bitfield; + done =0 ; +break ; + } + } + } + +if (mask_name !=NULL ) { + done =0 ; +switch (add) { +case '-' : + rg &= ~mask_bitfield; +break ; +case '+' : + rg |= mask_bitfield; +break ; +case '=' : + rg = mask_bitfield; +break ; +default : + rg |= mask_bitfield; +break ; + } + } + } + + yaffs_trace_mask = rg |YAFFS_TRACE_ALWAYS ; + +printk (KERN_DEBUG "new trace = 0x%08X\n" , yaffs_trace_mask); + +if (rg &YAFFS_TRACE_ALWAYS ) { +for (i =0 ; mask_flags[i].mask_name !=NULL ; i++) { +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); + } + } + +return count; +} + + +static int yaffs_proc_write (struct file *file,const char *buf, +unsigned long count,void *data) +{ +return yaffs_proc_write_trace_options (file, buf, count, data); +} + +/* Stuff to handle installation of file systems */ +struct file_system_to_install { +struct file_system_type *fst; +int installed; +}; + +static struct file_system_to_install fs_to_install[] = { + {&yaffs_fs_type,0 }, + {&yaffs2_fs_type,0 }, + {NULL ,0 } +}; + +static int __init init_yaffs_fs (void ) +{ +int error =0 ; +struct file_system_to_install *fsinst; + +T (YAFFS_TRACE_ALWAYS , + (TSTR ("yaffs built " __DATE__" " __TIME__" Installing. \n" ))); + +#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" ))); +#endif + + + + +init_MUTEX (&yaffs_context_lock); + +/* Install the proc_fs entries */ + my_proc_entry =create_proc_entry ("yaffs" , +S_IRUGO |S_IFREG , +YPROC_ROOT ); + +if (my_proc_entry) { + my_proc_entry->write_proc = yaffs_proc_write; + my_proc_entry->read_proc = yaffs_proc_read; + my_proc_entry->data =NULL ; + }else +return -ENOMEM ; + + debug_proc_entry =create_proc_entry ("yaffs_stats" , +S_IRUGO |S_IFREG , +YPROC_ROOT ); + +if (debug_proc_entry) { + debug_proc_entry->write_proc =NULL ; + debug_proc_entry->read_proc = yaffs_stats_proc_read; + debug_proc_entry->data =NULL ; + }else +return -ENOMEM ; + +/* Now add the file system entries */ + + fsinst = fs_to_install; + +while (fsinst->fst && !error) { + error =register_filesystem (fsinst->fst); +if (!error) + fsinst->installed =1 ; + fsinst++; + } + +/* Any errors? uninstall */ +if (error) { + fsinst = fs_to_install; + +while (fsinst->fst) { +if (fsinst->installed) { +unregister_filesystem (fsinst->fst); + fsinst->installed =0 ; + } + fsinst++; + } + } + +return error; +} + +static void __exit exit_yaffs_fs(void) +{ + +struct file_system_to_install *fsinst; + +T (YAFFS_TRACE_ALWAYS , + (TSTR ("yaffs built " __DATE__" " __TIME__" removing. \n" ))); + +remove_proc_entry ("yaffs" ,YPROC_ROOT );
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 1 line
1.7.3.2.146.gca209
Part of the diff is not shown here. View the raw message.
PATCH 26/29 Staging: yaffs2: yaffs_yaffs1: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_yaffs1.c | 457 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_yaffs1.h | 22 ++ 2 files changed, 479 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_yaffs1.c create mode 100644 drivers/staging/yaffs2/yaffs_yaffs1.h
drivers/staging/yaffs2/yaffs_yaffs1.c new file +457 -0
@@ -0,0 +1,457 @@ +/* +* 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 <[email protected]> +* +* 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_yaffs1.h" +#include "yportenv.h" +#include "yaffs_trace.h" +#include "yaffs_bitmap.h" +#include "yaffs_getblockinfo.h" +#include "yaffs_nand.h" + + +int yaffs1_scan (yaffs_dev_t *dev) +{ +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; + +int alloc_failed =0 ; + +struct yaffs_shadow_fixer_s *shadow_fixers =NULL ; + + +__u8 *chunk_data; + + + +T (YAFFS_TRACE_SCAN , + (TSTR ("yaffs1_scan starts intstartblk %d intendblk %d..." TENDSTR ), + dev->internal_start_block, dev->internal_end_block)); + + chunk_data =yaffs_get_temp_buffer (dev, __LINE__); + + dev->seq_number =YAFFS_LOWEST_SEQUENCE_NUMBER ; + +/* Scan all the blocks to determine their state */ + bi = dev->block_info; +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 ; + +yaffs_query_init_block_state (dev, blk, &state, &seq_number); + + bi->block_state = state; + bi->seq_number = seq_number; + +if (bi->seq_number ==YAFFS_SEQUENCE_BAD_BLOCK ) + bi->block_state = state =YAFFS_BLOCK_STATE_DEAD ; + +T (YAFFS_TRACE_SCAN_DEBUG , + (TSTR ("Block scanning block %d state %d seq %d" TENDSTR ), blk, + state, seq_number)); + +if (state ==YAFFS_BLOCK_STATE_DEAD ) { +T (YAFFS_TRACE_BAD_BLOCKS , + (TSTR ("block %d is bad" TENDSTR ), blk)); + }else if (state ==YAFFS_BLOCK_STATE_EMPTY ) { +T (YAFFS_TRACE_SCAN_DEBUG , + (TSTR ("Block empty " TENDSTR ))); + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; + } + bi++; + } + +/* For each block.... */ +for (blk= dev->internal_start_block; + !alloc_failed && blk <= dev->internal_end_block; + blk++) { + +YYIELD (); + + bi =yaffs_get_block_info (dev, blk); + state = bi->block_state; + + deleted =0 ; + +/* 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); + +/* Let's have a good look at this chunk... */ + +if (tags.ecc_result ==YAFFS_ECC_RESULT_UNFIXED || tags.is_deleted) { +/* YAFFS1 only... +* A deleted chunk +*/ + deleted++; + dev->n_free_chunks++; +/*T((" %d %d deleted\n",blk,c)); */ + }else if (!tags.chunk_used) { +/* An unassigned chunk in the block +* This means that either the block is empty or +* this is the one being allocated from +*/ + +if (c ==0 ) { +/* We're looking at the first chunk in the block so the block is unused */ + state =YAFFS_BLOCK_STATE_EMPTY ; + dev->n_erased_blocks++; + }else { +/* this is the block being allocated from */ +T (YAFFS_TRACE_SCAN , + (TSTR + (" Allocating from %d %d" TENDSTR ), + blk, c)); + state =YAFFS_BLOCK_STATE_ALLOCATING ; + dev->alloc_block = blk; + dev->alloc_page = c; + dev->alloc_block_finder = blk; +/* Set block finder here to encourage the allocator to go forth from here. */ + + } + + 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; + +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 ); +/* PutChunkIntoFile checks for a clash (two data chunks with +* the same chunk_id). +*/ + +if (!in) + alloc_failed =1 ; + +if (in) { +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.n_bytes; +if (in && + in->variant_type ==YAFFS_OBJECT_TYPE_FILE + && 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; + } + + } +/* T((" %d %d data %d %d\n",blk,c,tags.obj_id,tags.chunk_id)); */ + }else { +/* chunk_id == 0, so it is an ObjectHeader. +* Thus, we read in the object header and make the object +*/ +yaffs_set_chunk_bit (dev, blk, c); + bi->pages_in_use++; + + result =yaffs_rd_chunk_tags_nand (dev, chunk, + chunk_data, +NULL ); + + oh = (yaffs_obj_header *) chunk_data; + + 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 +* deleted, and worse still it has changed type. Delete the old object. +*/ + +yaffs_del_obj (in); + + in =0 ; + } + + in =yaffs_find_or_create_by_number (dev, + 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 )); +if (fixer) { + fixer->next = shadow_fixers; + shadow_fixers = fixer; + fixer->obj_id = tags.obj_id; + fixer->shadowed_id = oh->shadows_obj; +T (YAFFS_TRACE_SCAN , + (TSTR + (" Shadow fixer: %d shadows %d" TENDSTR ), + fixer->obj_id, fixer->shadowed_id)); + + } + + } + +if (in && in->valid) { +/* 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; + +if (((existing_serial +1 ) &3 ) == new_serial) { +/* Use new one - destroy the exisiting one */ +yaffs_chunk_del (dev, + in->hdr_chunk, +1 , __LINE__); + in->valid =0 ; + }else { +/* Use existing - destroy this one. */ +yaffs_chunk_del (dev, chunk,1 , + __LINE__); + } + } + +if (in && !in->valid && + (tags.obj_id ==YAFFS_OBJECTID_ROOT || + 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 + in->hdr_chunk = chunk; + in->serial = tags.serial_number; + + }else if (in && !in->valid) { +/* we need to load this info */ + + 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 + in->hdr_chunk = chunk; + in->serial = tags.serial_number; + +yaffs_set_obj_name_from_oh (in, oh); + in->dirty =0 ; + +/* directory stuff... +* hook up to parent +*/ + + parent = +yaffs_find_or_create_by_number + (dev, oh->parent_obj_id, +YAFFS_OBJECT_TYPE_DIRECTORY ); +if (!parent) + alloc_failed =1 ; +if (parent && parent->variant_type == +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 ) { +/* Hoosterman, another problem.... +* We're trying to use a non-directory as a directory +*/ + +T (YAFFS_TRACE_ERROR , + (TSTR + ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." +TENDSTR ))); + parent = dev->lost_n_found; + } + +yaffs_add_obj_to_dir (parent, in); + +if (0 && (parent == dev->del_dir || + parent == dev->unlinked_dir)) { + in->deleted =1 ;/* If it is unlinked at start up then it wants deleting */ + dev->n_deleted_files++; + } +/* Note re hardlinks. +* Since we might scan a hardlink before its equivalent object is scanned +* we put them all in a list. +* After scanning is complete, we should have all the objects, so we run through this +* list and fix up all the chains. +*/ + +switch (in->variant_type) { +case YAFFS_OBJECT_TYPE_UNKNOWN : +/* Todo got a problem */ +break ; +case YAFFS_OBJECT_TYPE_FILE : +if (dev->param.use_header_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->hard_links.next = + (struct ylist_head *) + hard_list; + hard_list = in; +break ; +case YAFFS_OBJECT_TYPE_DIRECTORY : +/* Do nothing */ +break ; +case YAFFS_OBJECT_TYPE_SPECIAL : +/* Do nothing */ +break ; +case YAFFS_OBJECT_TYPE_SYMLINK : + in->variant.symlink_variant.alias = +yaffs_clone_str (oh->alias); +if (!in->variant.symlink_variant.alias) + alloc_failed =1 ; +break ; + } + + } + } + } + +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 ; + } + +if (state ==YAFFS_BLOCK_STATE_ALLOCATING ) { +/* If the block was partially allocated then treat it as fully allocated.*/ + state =YAFFS_BLOCK_STATE_FULL ; + dev->alloc_block =-1 ; + } + + bi->block_state = state; + +/* Now let's see if it was dirty */ +if (bi->pages_in_use ==0 && + !bi->has_shrink_hdr && + bi->block_state ==YAFFS_BLOCK_STATE_FULL ) { +yaffs_block_became_dirty (dev, blk); + } + + } + + +/* 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 +* hardlinks. +*/ + +yaffs_link_fixup (dev, hard_list); + +/* Fix up any shadowed objects */ + { +struct yaffs_shadow_fixer_s *fixer; +yaffs_obj_t *obj; + +while (shadow_fixers) { + fixer = shadow_fixers; + shadow_fixers = fixer->next; +/* Complete the rename transaction by deleting the shadowed object +* then setting the object header to unshadowed. +*/ + obj =yaffs_find_by_number (dev, fixer->shadowed_id); +if (obj) +yaffs_del_obj (obj); + + obj =yaffs_find_by_number (dev, fixer->obj_id); + +if (obj) +yaffs_update_oh (obj,NULL ,1 ,0 ,0 ,NULL ); + +YFREE (fixer); + } + } + +yaffs_release_temp_buffer (dev, chunk_data, __LINE__); + +if (alloc_failed) +return YAFFS_FAIL ; + +T (YAFFS_TRACE_SCAN , (TSTR ("yaffs1_scan ends" TENDSTR ))); + + +return YAFFS_OK ; +} +
drivers/staging/yaffs2/yaffs_yaffs1.h new file +22 -0
@@ -0,0 +1,22 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_YAFFS1_H__ +#define __YAFFS_YAFFS1_H__ + +#include "yaffs_guts.h" +int yaffs1_scan (yaffs_dev_t *dev); + +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 27/29 Staging: yaffs2: yaffs_yaffs2: Add files
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yaffs_yaffs2.c | 1541 +++++++++++++++++++++++++++++++++ drivers/staging/yaffs2/yaffs_yaffs2.h | 38 + 2 files changed, 1579 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yaffs_yaffs2.c create mode 100644 drivers/staging/yaffs2/yaffs_yaffs2.h
drivers/staging/yaffs2/yaffs_yaffs2.c new file +1541 -0
@@ -0,0 +1,1541 @@ +/* +* 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 <[email protected]> +* +* 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_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" + +/* +* Checkpoints are really no benefit on very small partitions. +* +* To save space on small partitions don't bother with checkpoints unless +* the partition is at least this big. +*/ +#define YAFFS_CHECKPOINT_MIN_BLOCKS 60 + +#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) +{ +int i; +unsigned seq; +unsigned block_no =0 ; +yaffs_block_info_t *b; + +if (!dev->param.is_yaffs2) +return ; + +/* Find the oldest dirty sequence number. */ + seq = dev->seq_number +1 ; + 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) { + seq = b->seq_number; + block_no = i; + } + b++; + } + +if (block_no){ + dev->oldest_dirty_seq = seq; + dev->oldest_dirty_block = block_no; + } + +} + + +void yaffs2_find_oldest_dirty_seq (yaffs_dev_t *dev) +{ +if (!dev->param.is_yaffs2) +return ; + +if (!dev->oldest_dirty_seq) +yaffs_calc_oldest_dirty_seq (dev); +} + +/* +* yaffs_clear_oldest_dirty_seq() +* Called when a block is erased or marked bad. (ie. when its seq_number +* 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) +{ + +if (!dev->param.is_yaffs2) +return ; + +if (!bi || bi->seq_number == dev->oldest_dirty_seq){ + dev->oldest_dirty_seq =0 ; + dev->oldest_dirty_block =0 ; + } +} + +/* +* yaffs2_update_oldest_dirty_seq() +* 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) +{ +if (!dev->param.is_yaffs2) +return ; + +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) +{ + +if (!dev->param.is_yaffs2) +return 1 ;/* disqualification only applies to yaffs2. */ + +if (!bi->has_shrink_hdr) +return 1 ;/* can gc */ + +yaffs2_find_oldest_dirty_seq (dev); + +/* Can't do gc of this block if there are any blocks older than this one that have +* discarded pages. +*/ +return (bi->seq_number <= dev->oldest_dirty_seq); +} + +/* +* yaffs2_find_refresh_block() +* periodically finds the oldest full block by sequence number for refreshing. +* Only for yaffs2. +*/ +__u32 yaffs2_find_refresh_block (yaffs_dev_t *dev) +{ +__u32 b ; + +__u32 oldest =0 ; +__u32 oldest_seq =0 ; + +yaffs_block_info_t *bi; + +if (!dev->param.is_yaffs2) +return oldest; + +/* +* If refresh period < 10 then refreshing is disabled. +*/ +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; + +if (dev->refresh_skip >0 ) +return oldest; + +/* +* Refresh skip is now zero. +* We'll do a refresh this time around.... +* Update the refresh skip and find the oldest block. +*/ + 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++){ + +if (bi->block_state ==YAFFS_BLOCK_STATE_FULL ){ + +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)); + } + +return oldest; +} + +int yaffs2_checkpt_required (yaffs_dev_t *dev) +{ +int nblocks; + +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 ); +} + +int yaffs_calc_checkpt_blocks_required (yaffs_dev_t *dev) +{ +int retval; + +if (!dev->param.is_yaffs2) +return 0 ; + +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 ); + + 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 += 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*/ + +/* 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 ; + + dev->checkpoint_blocks_required = n_blocks; + } + + retval = dev->checkpoint_blocks_required - dev->blocks_in_checkpt; +if (retval <0 ) + retval =0 ; +return retval; +} + +/*--------------------- Checkpointing --------------------*/ + + +static int yaffs2_wr_checkpt_validity_marker (yaffs_dev_t *dev,int head) +{ +yaffs_checkpt_validty_t cp; + +memset (&cp,0 ,sizeof (cp)); + + cp.struct_type =sizeof (cp); + cp.magic =YAFFS_MAGIC ; + cp.version =YAFFS_CHECKPOINT_VERSION ; + cp.head = (head) ?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) +{ +yaffs_checkpt_validty_t 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 )); +return ok ?1 :0 ; +} + +static void yaffs2_dev_to_checkpt_dev (yaffs_checkpt_dev_t *cp, +yaffs_dev_t *dev) +{ + cp->n_erased_blocks = dev->n_erased_blocks; + cp->alloc_block = dev->alloc_block; + cp->alloc_page = dev->alloc_page; + cp->n_free_chunks = dev->n_free_chunks; + + cp->n_deleted_files = dev->n_deleted_files; + cp->n_unlinked_files = dev->n_unlinked_files; + cp->n_bg_deletions = dev->n_bg_deletions; + cp->seq_number = dev->seq_number; + +} + +static void yaffs_checkpt_dev_to_dev (yaffs_dev_t *dev, +yaffs_checkpt_dev_t *cp) +{ + dev->n_erased_blocks = cp->n_erased_blocks; + dev->alloc_block = cp->alloc_block; + dev->alloc_page = cp->alloc_page; + dev->n_free_chunks = cp->n_free_chunks; + + dev->n_deleted_files = cp->n_deleted_files; + dev->n_unlinked_files = cp->n_unlinked_files; + dev->n_bg_deletions = cp->n_bg_deletions; + dev->seq_number = cp->seq_number; +} + + +static int yaffs2_wr_checkpt_dev (yaffs_dev_t *dev) +{ +yaffs_checkpt_dev_t cp; +__u32 n_bytes; +__u32 n_blocks = (dev->internal_end_block - dev->internal_start_block +1 ); + +int ok; + +/* Write device runtime values*/ +yaffs2_dev_to_checkpt_dev (&cp, dev); + cp.struct_type =sizeof (cp); + + ok = (yaffs2_checkpt_wr (dev, &cp,sizeof (cp)) ==sizeof (cp)); + +/* 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); + } + +/* 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); + } +return ok ?1 :0 ; + +} + +static int yaffs2_rd_checkpt_dev (yaffs_dev_t *dev) +{ +yaffs_checkpt_dev_t cp; +__u32 n_bytes; +__u32 n_blocks = (dev->internal_end_block - dev->internal_start_block +1 ); + +int ok; + + ok = (yaffs2_checkpt_rd (dev, &cp,sizeof (cp)) ==sizeof (cp)); +if (!ok) +return 0 ; + +if (cp.struct_type !=sizeof (cp)) +return 0 ; + + +yaffs_checkpt_dev_to_dev (dev, &cp); + + n_bytes = n_blocks *sizeof (yaffs_block_info_t); + + ok = (yaffs2_checkpt_rd (dev, dev->block_info, n_bytes) == n_bytes); + +if (!ok) +return 0 ; + n_bytes = n_blocks * dev->chunk_bit_stride; + + ok = (yaffs2_checkpt_rd (dev, dev->chunk_bits, n_bytes) == n_bytes); + +return ok ?1 :0 ; +} + +static void yaffs2_obj_checkpt_obj (yaffs_checkpt_obj_t *cp, +yaffs_obj_t *obj) +{ + + cp->obj_id = obj->obj_id; + cp->parent_id = (obj->parent) ? obj->parent->obj_id :0 ; + cp->hdr_chunk = obj->hdr_chunk; + cp->variant_type = obj->variant_type; + cp->deleted = obj->deleted; + cp->soft_del = obj->soft_del; + cp->unlinked = obj->unlinked; + cp->fake = obj->fake; + cp->rename_allowed = obj->rename_allowed; + cp->unlink_allowed = obj->unlink_allowed; + cp->serial = obj->serial; + cp->n_data_chunks = obj->n_data_chunks; + +if (obj->variant_type ==YAFFS_OBJECT_TYPE_FILE ) + cp->size_or_equiv_obj = obj->variant.file_variant.file_size; +else if (obj->variant_type ==YAFFS_OBJECT_TYPE_HARDLINK ) + 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) +{ + +yaffs_obj_t *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)); +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 ); +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)); +return 0 ; + } +yaffs_add_obj_to_dir (parent, obj); + } + + obj->hdr_chunk = cp->hdr_chunk; + obj->variant_type = cp->variant_type; + obj->deleted = cp->deleted; + obj->soft_del = cp->soft_del; + obj->unlinked = cp->unlinked; + obj->fake = cp->fake; + obj->rename_allowed = cp->rename_allowed; + obj->unlink_allowed = cp->unlink_allowed; + obj->serial = cp->serial; + obj->n_data_chunks = cp->n_data_chunks; + +if (obj->variant_type ==YAFFS_OBJECT_TYPE_FILE ) + obj->variant.file_variant.file_size = cp->size_or_equiv_obj; +else if (obj->variant_type ==YAFFS_OBJECT_TYPE_HARDLINK ) + obj->variant.hardlink_variant.equiv_id = cp->size_or_equiv_obj; + +if (obj->hdr_chunk >0 ) + obj->lazy_loaded =1 ; +return 1 ; +} + + + +static int yaffs2_checkpt_tnode_worker (yaffs_obj_t *in,yaffs_tnode_t *tn, +__u32 level,int chunk_offset) +{ +int i; +yaffs_dev_t *dev = in->my_dev; +int ok =1 ; + +if (tn) { +if (level >0 ) { + +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<<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)); +if (ok) + ok = (yaffs2_checkpt_wr (dev, tn, dev->tnode_size) == dev->tnode_size); + } + } + +return ok; + +} + +static int yaffs2_wr_checkpt_tnodes (yaffs_obj_t *obj) +{ +__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 ); +if (ok) + 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) +{ +__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; +int nread =0 ; + + 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); + }else + ok =0 ; + +if (tn && ok) + ok =yaffs_add_find_tnode_0 (dev, + file_stuct_ptr, + base_chunk, + tn) ?1 :0 ; + +if (ok) + 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)); + +return ok ?1 :0 ; +} + + +static int yaffs2_wr_checkpt_objs (yaffs_dev_t *dev) +{ +yaffs_obj_t *obj; +yaffs_checkpt_obj_t cp; +int i; +int ok =1 ; +struct ylist_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) { +if (lh) { + obj =ylist_entry (lh, yaffs_obj_t, 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); + } + } + } + } + +/* Dump end of list */ +memset (&cp,0xFF ,sizeof (yaffs_checkpt_obj_t)); + cp.struct_type =sizeof (cp); + +if (ok) + ok = (yaffs2_checkpt_wr (dev, &cp,sizeof (cp)) ==sizeof (cp)); + +return ok ?1 :0 ; +} + +static int yaffs2_rd_checkpt_objs (yaffs_dev_t *dev) +{ +yaffs_obj_t *obj; +yaffs_checkpt_obj_t cp; +int ok =1 ; +int done =0 ; +yaffs_obj_t *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)); + 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)); + +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); +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 ) { + obj->hard_links.next = + (struct ylist_head *) hard_list; + hard_list = obj; + } + }else + ok =0 ; + } + } + +if (ok) +yaffs_link_fixup (dev, hard_list); + +return ok ?1 :0 ; +} + +static int yaffs2_wr_checkpt_sum (yaffs_dev_t *dev) +{ +__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)); + +if (!ok) +return 0 ; + +return 1 ; +} + +static int yaffs2_rd_checkpt_sum (yaffs_dev_t *dev) +{ +__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)); + +if (!ok) +return 0 ; + +if (checkpt_sum0 != checkpt_sum1) +return 0 ; + +return 1 ; +} + + +static int yaffs2_wr_checkpt_data (yaffs_dev_t *dev) +{ +int ok =1 ; + +if (!yaffs2_checkpt_required (dev)) { +T (YAFFS_TRACE_CHECKPOINT , (TSTR ("skipping checkpoint write" TENDSTR ))); + ok =0 ; + } + +if (ok) + ok =yaffs2_checkpt_open (dev,1 ); + +if (ok) { +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 ))); + ok =yaffs2_wr_checkpt_dev (dev); + } +if (ok) { +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 ))); + ok =yaffs2_wr_checkpt_validity_marker (dev,0 ); + } + +if (ok) + ok =yaffs2_wr_checkpt_sum (dev); + +if (!yaffs_checkpt_close (dev)) + ok =0 ; + +if (ok) + dev->is_checkpointed =1 ; +else + dev->is_checkpointed =0 ; + +return dev->is_checkpointed; +} + +static int yaffs2_rd_checkpt_data (yaffs_dev_t *dev) +{ +int ok =1 ; + +if (!dev->param.is_yaffs2) + ok =0 ; + +if (ok && dev->param.skip_checkpt_rd) { +T (YAFFS_TRACE_CHECKPOINT , (TSTR ("skipping checkpoint read" TENDSTR ))); + ok =0 ; + } + +if (ok) + 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 ); + } +if (ok) { +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 ))); + 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 ); + } + +if (ok) { + ok =yaffs2_rd_checkpt_sum (dev); +T (YAFFS_TRACE_CHECKPOINT , (TSTR ("read checkpoint checksum %d" TENDSTR ), ok)); + } + +if (!yaffs_checkpt_close (dev)) + ok =0 ; + +if (ok) + dev->is_checkpointed =1 ; +else + dev->is_checkpointed =0 ; + +return ok ?1 :0 ; + +} + +void yaffs2_checkpt_invalidate (yaffs_dev_t *dev) +{ +if (dev->is_checkpointed || + dev->blocks_in_checkpt >0 ) { + dev->is_checkpointed =0 ; +yaffs2_checkpt_invalidate_stream (dev); + } +if (dev->param.sb_dirty_fn) + dev->param.sb_dirty_fn (dev); +} + + +int yaffs_checkpoint_save (yaffs_dev_t *dev) +{ + +T (YAFFS_TRACE_CHECKPOINT , (TSTR ("save entry: is_checkpointed %d" TENDSTR ), dev->is_checkpointed)); + +yaffs_verify_objects (dev); +yaffs_verify_blocks (dev); +yaffs_verify_free_chunks (dev); + +if (!dev->is_checkpointed) { +yaffs2_checkpt_invalidate (dev); +yaffs2_wr_checkpt_data (dev); + } + +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 retval; +T (YAFFS_TRACE_CHECKPOINT , (TSTR ("restore entry: is_checkpointed %d" TENDSTR ), dev->is_checkpointed)); + + retval =yaffs2_rd_checkpt_data (dev); + +if (dev->is_checkpointed) { +yaffs_verify_objects (dev); +yaffs_verify_blocks (dev); +yaffs_verify_free_chunks (dev); + } + +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) +{ +/* 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 result =YAFFS_OK ; +yaffs_dev_t *dev =NULL ; + +__u8 *local_buffer =NULL ; + +int small_increase_ok =0 ; + +if (!obj) +return YAFFS_FAIL ; + +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) +return YAFFS_OK ; + + old_file_size = obj->variant.file_variant.file_size; + +if (new_size <= old_file_size) +return YAFFS_OK ; + + 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 )) + small_hole =1 ; +else + small_hole =0 ; + +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); + small_increase_ok =1 ; + +while (increase >0 && small_increase_ok){ + this_write = increase; +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){ + pos += this_write; + increase -= this_write; + }else + small_increase_ok =0 ; + } + +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) +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 ){ +/* Write a hole start header with the old file size */ +yaffs_update_oh (obj,NULL ,0 ,1 ,0 ,NULL ); + } + +return result; + +} + + +typedef struct { +int seq; +int block; +}yaffs_block_index ; + + +static int yaffs2_ybicmp (const void *a,const void *b) +{ + registerint aseq = ((yaffs_block_index *)a)->seq; + registerint bseq = ((yaffs_block_index *)b)->seq; + registerint ablock = ((yaffs_block_index *)a)->block; + registerint bblock = ((yaffs_block_index *)b)->block; +if (aseq == bseq) +return ablock - bblock; +else +return aseq - bseq; +} + +int yaffs2_scan_backwards (yaffs_dev_t *dev) +{ +yaffs_ext_tags tags; +int blk; +int block_iter; +int start_iter; +int end_iter; +int n_to_scan =0 ; + +int chunk; +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; +int n_blocks = dev->internal_end_block - dev->internal_start_block +1 ; +int is_unlinked; +__u8 *chunk_data; + +int file_size; +int is_shrink; +int found_chunks; +int equiv_id; +int alloc_failed =0 ; + + +yaffs_block_index *block_index =NULL ; +int alt_block_index =0 ; + +T (YAFFS_TRACE_SCAN , + (TSTR + ("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)); + +if (!block_index) { + block_index =YMALLOC_ALT (n_blocks *sizeof (yaffs_block_index)); + alt_block_index =1 ; + } + +if (!block_index) { +T (YAFFS_TRACE_SCAN , + (TSTR ("yaffs2_scan_backwards() could not allocate block index!" TENDSTR ))); +return YAFFS_FAIL ; + } + + dev->blocks_in_checkpt =0 ; + + chunk_data =yaffs_get_temp_buffer (dev, __LINE__); + +/* Scan all the blocks to determine their state */ + bi = dev->block_info; +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 ; + +yaffs_query_init_block_state (dev, blk, &state, &seq_number); + + bi->block_state = state; + bi->seq_number = seq_number; + +if (bi->seq_number ==YAFFS_SEQUENCE_CHECKPOINT_DATA ) + bi->block_state = state =YAFFS_BLOCK_STATE_CHECKPOINT ; +if (bi->seq_number ==YAFFS_SEQUENCE_BAD_BLOCK ) + bi->block_state = state =YAFFS_BLOCK_STATE_DEAD ; + +T (YAFFS_TRACE_SCAN_DEBUG , + (TSTR ("Block scanning block %d state %d seq %d" TENDSTR ), blk, + state, seq_number)); + + +if (state ==YAFFS_BLOCK_STATE_CHECKPOINT ) { + dev->blocks_in_checkpt++; + + }else if (state ==YAFFS_BLOCK_STATE_DEAD ) { +T (YAFFS_TRACE_BAD_BLOCKS , + (TSTR ("block %d is bad" TENDSTR ), blk)); + }else if (state ==YAFFS_BLOCK_STATE_EMPTY ) { +T (YAFFS_TRACE_SCAN_DEBUG , + (TSTR ("Block empty " TENDSTR ))); + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; + }else if (state ==YAFFS_BLOCK_STATE_NEEDS_SCANNING ) { + +/* Determine the highest sequence number */ +if (seq_number >=YAFFS_LOWEST_SEQUENCE_NUMBER && + seq_number <YAFFS_HIGHEST_SEQUENCE_NUMBER ) { + + block_index[n_to_scan].seq = seq_number; + block_index[n_to_scan].block = blk; + + n_to_scan++; + +if (seq_number >= dev->seq_number) + dev->seq_number = seq_number; + }else { +/* TODO: Nasty sequence number! */ +T (YAFFS_TRACE_SCAN , + (TSTR + ("Block scanning block %d has bad sequence number %d" +TENDSTR ), blk, seq_number)); + + } + } + bi++; + } + +T (YAFFS_TRACE_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); + +YYIELD (); + +T (YAFFS_TRACE_SCAN , (TSTR ("...done" TENDSTR ))); + +/* Now scan the blocks looking at the data. */ + start_iter =0 ; + end_iter = n_to_scan -1 ; +T (YAFFS_TRACE_SCAN_DEBUG , + (TSTR ("%d blocks to be scanned" TENDSTR ), n_to_scan)); + +/* For each block.... backwards */ +for (block_iter = end_iter; !alloc_failed && block_iter >= start_iter; + block_iter--) { +/* Cooperative multitasking! This loop can run for so +long that watchdog timers expire. */ +YYIELD (); + +/* get the block to scan in the correct order */ + blk = block_index[block_iter].block; + + bi =yaffs_get_block_info (dev, blk); + + + state = bi->block_state; + + deleted =0 ; + +/* For each chunk in each block that needs scanning.... */ + found_chunks =0 ; +for (c = dev->param.chunks_per_block -1 ; + !alloc_failed && c >=0 && + (state ==YAFFS_BLOCK_STATE_NEEDS_SCANNING || + state ==YAFFS_BLOCK_STATE_ALLOCATING ); c--) { +/* Scan backwards... +* 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); + +/* Let's have a good look at this chunk... */ + +if (!tags.chunk_used) { +/* An unassigned chunk in the block. +* If there are used chunks after this one, then +* it is a chunk that was skipped due to failing the erased +* check. Just skip it so that it can be deleted. +* But, more typically, We get here when this is an unallocated +* chunk and his means that either the block is empty or +* this is the one being allocated from +*/ + +if (found_chunks) { +/* This is a chunk that was skipped due to failing the erased check */ + }else if (c ==0 ) { +/* We're looking at the first chunk in the block so the block is unused */ + 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) { +/* this is the block being allocated from */ + +T (YAFFS_TRACE_SCAN , + (TSTR + (" Allocating from %d %d" +TENDSTR ), blk, c)); + + state =YAFFS_BLOCK_STATE_ALLOCATING ; + dev->alloc_block = blk; + dev->alloc_page = c; + 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)); + } + } + } + + dev->n_free_chunks++; + + }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)); + + 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 ) { +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)); + + 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; + + 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 ); +if (!in) { +/* Out of memory */ + alloc_failed =1 ; + } + +if (in && + in->variant_type ==YAFFS_OBJECT_TYPE_FILE + && 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 )) { + alloc_failed =1 ; + } + +/* File size is calculated by looking at the data chunks if we have not +* seen an object header yet. Stop this practice once we find an object header. +*/ + 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; + } + + }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__); + + } + }else { +/* chunk_id == 0, so it is an ObjectHeader. +* Thus, we read in the object header and make the object +*/ + found_chunks =1 ; + +yaffs_set_chunk_bit (dev, blk, c); + bi->pages_in_use++; + + oh =NULL ; + in =NULL ; + +if (tags.extra_available) { + in =yaffs_find_or_create_by_number (dev, + 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 ))) { + +/* 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 +* living with invalid data until needed. +*/ + + result =yaffs_rd_chunk_tags_nand (dev, + chunk, + chunk_data, +NULL ); + + oh = (yaffs_obj_header *) 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; + } + +if (!in) { + in =yaffs_find_or_create_by_number (dev, tags.obj_id, oh->type); +if (!in) + alloc_failed =1 ; + } + + } + +if (!in) { +/* TODO Hoosterman we have a problem! */ +T (YAFFS_TRACE_ERROR , + (TSTR + ("yaffs tragedy: Could not make object for object %d at chunk %d during scan" +TENDSTR ), tags.obj_id, chunk)); +continue ; + } + +if (in->valid) { +/* We have already filled this one. +* We have a duplicate that will be discarded, but +* 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 = + (oh) ? oh-> + parent_obj_id : tags. + extra_parent_id; + + + 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. +*/ +if (parent_obj_id == +YAFFS_OBJECTID_DELETED + || parent_obj_id == +YAFFS_OBJECTID_UNLINKED ) { + this_size =0 ; + 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) + bi->has_shrink_hdr =1 ; + + } +/* Use existing - destroy this one. */ +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 ") + TCONT("%d during scan") +TENDSTR ), oh ? + oh->type : tags.extra_obj_type, + in->variant_type, tags.obj_id, + chunk)); + +if (!in->valid && + (tags.obj_id ==YAFFS_OBJECTID_ROOT || + tags.obj_id == +YAFFS_OBJECTID_LOSTNFOUND )) { +/* We only load some info, don't fiddle with directory structure */ + in->valid =1 ; + +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; + + in->lazy_loaded =0 ; + +#endif + }else + in->lazy_loaded =1 ; + + in->hdr_chunk = chunk; + + }else if (!in->valid) { +/* we need to load this info */ + + in->valid =1 ; + in->hdr_chunk = chunk; + +if (oh) { + 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 + +if (oh->shadows_obj >0 ) +yaffs_handle_shadowed_obj (dev, + oh-> + shadows_obj, +1 ); + + + +yaffs_set_obj_name_from_oh (in, oh); + parent = +yaffs_find_or_create_by_number + (dev, oh->parent_obj_id, +YAFFS_OBJECT_TYPE_DIRECTORY ); + + file_size = oh->file_size; + is_shrink = oh->is_shrink; + equiv_id = oh->equiv_id; + + }else { + 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; + in->lazy_loaded =1 ; + + } + in->dirty =0 ; + +if (!parent) + alloc_failed =1 ; + +/* directory stuff... +* hook up to parent +*/ + +if (parent && parent->variant_type == +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 ) { +/* Hoosterman, another problem.... +* We're trying to use a non-directory as a directory +*/ + +T (YAFFS_TRACE_ERROR , + (TSTR + ("yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." +TENDSTR ))); + parent = dev->lost_n_found; + } + +yaffs_add_obj_to_dir (parent, in); + + is_unlinked = (parent == dev->del_dir) || + (parent == dev->unlinked_dir); + +if (is_shrink) { +/* Mark the block as having a shrink header */ + bi->has_shrink_hdr =1 ; + } + +/* Note re hardlinks. +* Since we might scan a hardlink before its equivalent object is scanned +* we put them all in a list. +* After scanning is complete, we should have all the objects, so we run +* through this list and fix up all the chains. +*/ + +switch (in->variant_type) { +case YAFFS_OBJECT_TYPE_UNKNOWN : +/* Todo got a problem */ +break ; +case YAFFS_OBJECT_TYPE_FILE : + +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; + } + +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->hard_links.next = + (struct ylist_head *) hard_list; + hard_list = in; + } +break ; +case YAFFS_OBJECT_TYPE_DIRECTORY : +/* Do nothing */ +break ; +case YAFFS_OBJECT_TYPE_SPECIAL : +/* Do nothing */ +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 ; + } +break ; + } + + } + + } + + }/* 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 */ +if (bi->pages_in_use ==0 && + !bi->has_shrink_hdr && + bi->block_state ==YAFFS_BLOCK_STATE_FULL ) { +yaffs_block_became_dirty (dev, blk); + } + + } + +yaffs_skip_rest_of_block (dev); + +if (alt_block_index) +YFREE_ALT (block_index); +else +YFREE (block_index); + +/* 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 +* hardlinks. +*/ +yaffs_link_fixup (dev, hard_list); + + +yaffs_release_temp_buffer (dev, chunk_data, __LINE__); + +if (alloc_failed) +return YAFFS_FAIL ; + +T (YAFFS_TRACE_SCAN , (TSTR ("yaffs2_scan_backwards ends" TENDSTR ))); + +return YAFFS_OK ; +}
drivers/staging/yaffs2/yaffs_yaffs2.h new file +38 -0
@@ -0,0 +1,38 @@ +/* +* 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 <[email protected]> +* +* 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 __YAFFS_YAFFS2_H__ +#define __YAFFS_YAFFS2_H__ + +#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 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); + +#endif
Signature · 1 line
1.7.3.2.146.gca209
PATCH 28/29 Staging: yaffs2: yportenv.h: Add file
In reply to Tracey DentAdding files to yaffs2 directory.
--- drivers/staging/yaffs2/yportenv.h | 333 +++++++++++++++++++++++++++++++++++++ 1 files changed, 333 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/yportenv.h
drivers/staging/yaffs2/yportenv.h new file +333 -0
@@ -0,0 +1,333 @@ +/* +* 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 <[email protected]> +* +* 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. +*/ + +#define MTD_VERSION (a, b, c) (((a) << 16) + ((b) << 8) + (c)) + +#if definedCONFIG_YAFFS_WINCE + +#include "ywinceenv.h" + +#elif defined __KERNEL__ + +#include "moduleconfig.h" + +/* Linux kernel */ + +#include <linux/version.h> +#define MTD_VERSION_CODE LINUX_VERSION_CODE + +#if (LINUX_VERSION_CODE <KERNEL_VERSION (2 ,6 ,19 )) +#include <linux/config.h> +#endif + +#include <linux/kernel.h> +#include <linux/mm.h> +#include <linux/sched.h> +#include <linux/string.h> +#include <linux/slab.h> +#include <linux/vmalloc.h> +#include <linux/xattr.h> + +#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 Y_INLINE __inline__ + +#define YAFFS_LOSTNFOUND_NAME "lost+found" +#define YAFFS_LOSTNFOUND_PREFIX "obj" + +/* #define YPRINTF(x) printk x */ +#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 + +#if (LINUX_VERSION_CODE >KERNEL_VERSION (2 ,5 ,0 )) +#define Y_CURRENT_TIME CURRENT_TIME.tv_sec +#define Y_TIME_CONVERT (x) (x).tv_sec +#else +#define Y_CURRENT_TIME CURRENT_TIME +#define Y_TIME_CONVERT (x) (x) +#endif + +#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; }) + +#elif definedCONFIG_YAFFS_DIRECT + +#define MTD_VERSION_CODE MTD_VERSION(2, 6, 22) + +/* Direct interface */ +#include "ydirectenv.h" + +#elif definedCONFIG_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 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 <errno.h> +#include <sys/stat.h> +#include <fcntl.h> +#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
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 28/29] Staging: yaffs2: yportenv.h: Add file
Quoted 28 lines · Tracey Dent
Adding files to yaffs2 directory.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/yportenv.h | 333 +++++++++++++++++++++++++++++++++++++1 files changed, 333 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/yportenv.hdrivers/staging/yaffs2/yportenv.h new file +15
-0+#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 Y_INLINE __inline__ + +#define YAFFS_LOSTNFOUND_NAME "lost+found" +#define YAFFS_LOSTNFOUND_PREFIX "obj"
drivers/staging/yaffs2/yportenv.h line 77
Quoted 10 lines
drivers/staging/yaffs2/yportenv.h new file +10
-0+ +/* #define YPRINTF(x) printk x */ +#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()
[snip]
Pretty much all wrappers in this header file want to be killed. --
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH 29/29 Staging: yaffs2: TODO: Add TODO file
In reply to Tracey DentInital TODO file.
--- drivers/staging/yaffs2/TODO | 6 ++++++ 1 files changed, 6 insertions(+), 0 deletions(-) create mode 100644 drivers/staging/yaffs2/TODO
drivers/staging/yaffs2/TODO new file +6 -0
@@ -0,0 +1,6 @@ +TODO : + + * checkpatch.pl fixes + * sparse fixes + +Plase send patches to Greg Kroah-Hartman <[email protected]>
Signature · 1 line
1.7.3.2.146.gca209
Re: [PATCH 29/29] Staging: yaffs2: TODO: Add TODO file
Quoted 14 lines · Tracey Dent
Inital TODO file.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/TODO | 6 ++++++1 files changed, 6 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/TODOdrivers/staging/yaffs2/TODO new file +0
-0
drivers/staging/yaffs2/TODO line 4
Quoted 4 lines
drivers/staging/yaffs2/TODO new file +4
-0@@ -0,0 +1,6 @@ +TODO : + + * checkpatch.pl fixes + * sparse fixes
* drop typedefs
* drop Linux kernel version compatibility macros
* drop other strange compatibility macros
* fix formatting with Lindent
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCH 29/29] Staging: yaffs2: TODO: Add TODO file
Quoted 9 lines · On Tuesday 02 November 2010 08:20:27 Pekka Enberg wrote:
Quoted 8 lines · Tracey Dent
Inital TODO file.
Signed-off-by Tracey Dent <[email protected]>---
drivers/staging/yaffs2/TODO | 6 ++++++1 files changed, 6 insertions(+), 0 deletions(-)create mode 100644
drivers/staging/yaffs2/TODO
Quoted 15 lines
drivers/staging/yaffs2/TODO line 4
Quoted 10 lines
drivers/staging/yaffs2/TODO new file +4
-0@@ -0,0 +1,6 @@ +TODO : + + * checkpatch.pl fixes + * sparse fixes* drop typedefs
* drop Linux kernel version compatibility macros
* drop other strange compatibility macros
* fix formatting with Lindent
I am in the process of making up a new patch set for release within 24 hours that does the following:
* drops typedefs
* drops the last few camel case names
* replaces __u32 with u32 etc
* drops few remaining kernel version compatibility macros.
* cleans up #if 0 code
* clean up some of the headers etc reported today.
It is my goal to keep the code portable which is going to be a bit of a challenge, but I want to at least make an effort to do this.
Thanks to all for their comments etc. I appreciate the effort.
I shall be pushing this to git as well as sending out patches.
-- CHarles
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 4 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory.
It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
Quoted 8 lines
This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Thanks in advance for enlightening us as to what is going on here, David Daney
Quoted 12 lines · David Daney
Quoted 11 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory.
It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Quoted 8 lines
Quoted 1 line
Tracey Dent
I am confused.
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Yeah, we need to get the authorship correct here. Charles, do you ack these patches?
thanks,
greg k-h
Quoted 17 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 5 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
Quoted 8 lines
This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Quoted 7 lines
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Thanks in advance for enlightening us as to what is going on here, David Daney
We are not working together on this, but I do appreciate the effort in helping bring to a head what people like/dislike.
I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so that it is easier to add changes from yaffs.net.
-- Charles
Quoted 14 lines · Charles Manning
Quoted 13 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 12 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Quoted 8 lines
Quoted 8 lines
Quoted 1 line
Tracey Dent
I am confused.
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Yeah I forgot to change that. By adding a signed off line by him.
Quoted 10 lines
Quoted 3 lines
Thanks in advance for enlightening us as to what is going on here, David Daney
We are not working together on this, but I do appreciate the effort in helping
bring to a head what people like/dislike.I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so that it is easier to add changes from yaffs.net.
All I did was take your tree and put it in patch form. So nothing should change, except I added a general *TODO file.
So you can ack this and get it in Greg'ss Staging-next tree, if you want?
Quoted 4 lines
-- Charles
Regards,
Tracey Dent
Quoted 23 lines · Charles Manning
Quoted 22 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 5 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
Quoted 8 lines
This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Quoted 9 lines
Quoted 2 lines
Thanks in advance for enlightening us as to what is going on here, David Daney
We are not working together on this, but I do appreciate the effort in helping bring to a head what people like/dislike.
I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so that it is easier to add changes from yaffs.net.
Great. Thanks for clearing things up.
I will offer my unsolicited opinion:
Charles has obviously expended great effort on yaffs2. He has a git repository hosting the code, and has expressed a desire to get the code fit for merging. For Tracey Dent to come along and hijack the entire effort, would anger me if I were in Charles' place.
Having used yaffs2 in the past, I would like to see the code in the kernel. Having it come via Charles would seem to make sense.
David Daney
Quoted 34 lines · On Tuesday 02 November 2010 08:24:42 David Daney wrote:
Quoted 24 lines · Charles Manning
Quoted 23 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 8 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
This only the inital support and I will be sending more cleanup patches.
Quoted 6 lines
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Quoted 8 lines
Quoted 2 lines
Thanks in advance for enlightening us as to what is going on here, David Daney
We are not working together on this, but I do appreciate the effort in helping bring to a head what people like/dislike.
I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so that it is easier to add changes from yaffs.net.
Quoted 8 lines
Great. Thanks for clearing things up.
I will offer my unsolicited opinion:
Charles has obviously expended great effort on yaffs2. He has a git repository hosting the code, and has expressed a desire to get the code fit for merging. For Tracey Dent to come along and hijack the entire effort, would anger me if I were in Charles' place.
I don't see any malicious intent from Tracey, but I do wish to see some recognition for 8+ years of effort :-).
Quoted 3 lines
Having used yaffs2 in the past, I would like to see the code in the kernel. Having it come via Charles would seem to make sense.
A prime consideration from me is to try keep the kernel and yaffs.net versions of yaffs very close to consistent. That will allow me to continue to use my existing out-of-kernel dev tools and have other benefits.
-- CHarles
Quoted 40 lines · Charles Manning
Quoted 39 lines · On Tuesday 02 November 2010 08:24:42 David Daney wrote:
Quoted 25 lines · Charles Manning
Quoted 24 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 9 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything
is compile tested and it builds.This only the inital support and I will be sending more cleanup patches.
Quoted 6 lines
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Quoted 8 lines
Quoted 2 lines
Thanks in advance for enlightening us as to what is going on here, David Daney
We are not working together on this, but I do appreciate the effort in helping bring to a head what people like/dislike.
I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so that it is easier to add changes from yaffs.net.
Great. Thanks for clearing things up.
I will offer my unsolicited opinion:
Quoted 8 lines
Quoted 4 lines
Charles has obviously expended great effort on yaffs2. He has a git repository hosting the code, and has expressed a desire to get the code fit for merging. For Tracey Dent to come along and hijack the entire effort, would anger me if I were in Charles' place.
I don't see any malicious intent from Tracey, but I do wish to see some recognition for 8+ years of effort :-).
I can resend it with your signed-off-by line instead of mine.
Quoted 9 lines
Quoted 3 lines
Having used yaffs2 in the past, I would like to see the code in the kernel. Having it come via Charles would seem to make sense.
A prime consideration from me is to try keep the kernel and yaffs.net versions
of yaffs very close to consistent. That will allow me to continue to use my existing out-of-kernel dev tools and have other benefits.
Like I said its exactly from the git tree(http://github.com/cdhmanning/linux-yaffs-integration/). It should still be compatible with all the existing tools.
Quoted 4 lines
-- CHarles
Tracey Dent
Quoted 46 lines · Tracey Dent
Quoted 45 lines · Charles Manning
Quoted 43 lines · On Tuesday 02 November 2010 08:24:42 David Daney wrote:
Quoted 25 lines · Charles Manning
Quoted 24 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 9 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything
is compile tested and it builds.This only the inital support and I will be sending more cleanup patches.
Quoted 6 lines
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Quoted 8 lines
Quoted 2 lines
Thanks in advance for enlightening us as to what is going on here, David Daney
We are not working together on this, but I do appreciate the effort in helping bring to a head what people like/dislike.
I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so that it is easier to add changes from yaffs.net.
Great. Thanks for clearing things up.
I will offer my unsolicited opinion:
Charles has obviously expended great effort on yaffs2. He has a git repository hosting the code, and has expressed a desire to get the code fit for merging. For Tracey Dent to come along and hijack the entire effort, would anger me if I were in Charles' place.
Quoted 5 lines
Quoted 3 lines
I don't see any malicious intent from Tracey, but I do wish to see some recognition for 8+ years of effort :-).
I can resend it with your signed-off-by line instead of mine.
You need to properly credit _who_ did the code in the first place. And your patches did not do that at all, which is very bad, and rude, and something that we care deeply about.
Please read the file, Documentation/SubmittingPatches for how to properly attribute the author of the patch when you send it out.
I'm not going to take this as-is because of this problem, and neither will any other maintainer. Someone can resend it with the proper author and signed-off-by stuff and I'll be glad to look at it again then.
thanks,
greg k-h
Quoted 60 lines · Greg KH
Quoted 49 lines · Tracey Dent
Quoted 48 lines · Charles Manning
Quoted 46 lines · On Tuesday 02 November 2010 08:24:42 David Daney wrote:
Quoted 29 lines · Charles Manning
Quoted 19 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 9 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything
is compile tested and it builds.This only the inital support and I will be sending more cleanup patches.
Quoted 6 lines
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Quoted 8 lines
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are
there no From: and Signed-off-by headers for him?Thanks in advance for enlightening us as to what is going on here, David Daney
Quoted 7 lines
We are not working together on this, but I do appreciate the effort in
helping bring to a head what people like/dislike.I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs
so that it is easier to add changes from yaffs.net.Great. Thanks for clearing things up.
I will offer my unsolicited opinion:
Charles has obviously expended great effort on yaffs2. He has a git repository hosting the code, and has expressed a desire to get the code fit for merging. For Tracey Dent to come along and hijack the entire effort, would anger me if I were in Charles' place.
Quoted 5 lines
Quoted 3 lines
I don't see any malicious intent from Tracey, but I do wish to see some recognition for 8+ years of effort :-).
I can resend it with your signed-off-by line instead of mine.
You need to properly credit _who_ did the code in the first place. And your patches did not do that at all, which is very bad, and rude, and something that we care deeply about.
Quoted 7 lines
Please read the file,
Documentation/SubmittingPatchesfor how to properly attribute the author of the patch when you send it out.I'm not going to take this as-is because of this problem, and neither will any other maintainer. Someone can resend it with the proper author and signed-off-by stuff and I'll be glad to look at it again then.
Sorry for not giving credit. I will resend following patch set with proper credits.
Quoted 3 lines
thanks,
greg k-h
Sorry,
Tracey Dent
Quoted 1 line · Tracey Dent
On 11/1/10, Greg KH<[email protected]> wrote:
[...]
Quoted 8 lines
Quoted 8 lines
You need to properly credit _who_ did the code in the first place. And your patches did not do that at all, which is very bad, and rude, and something that we care deeply about.
Please read the file,
Documentation/SubmittingPatchesfor how to properly attribute the author of the patch when you send it out.
Quoted 8 lines
Quoted 4 lines
I'm not going to take this as-is because of this problem, and neither will any other maintainer. Someone can resend it with the proper author and signed-off-by stuff and I'll be glad to look at it again then.
Sorry for not giving credit. I will resend following patch set with proper credits.
It is not a race to see who can spam lkml first. Please consider coordinating with Charles, and perhaps even defer to him if he wishes to send the patches (or even have them pulled from his git repository).
David Daney.
Sorry for all the noise. It wont happen again. I just did something without thinking.
regards
Tracey
Quoted 2 lines · Tracey Dent
Sorry for all the noise. It wont happen again. I just did something without thinking.
There's nothing wrong with that, just get the patches correct next time and all will be fine :)
thanks,
greg k-h
Quoted 6 lines · Greg KH
Quoted 2 lines · Tracey Dent
Sorry for all the noise. It wont happen again. I just did something without thinking.
There's nothing wrong with that, just get the patches correct next time and all will be fine :)
But what about what David had said, that I never even coordinated with Charles to see if he even wanted me to do this patch set.
Quoted 5 lines
thanks,
greg k-h
regard
tracey d
Quoted 36 lines · David Daney
Quoted 26 lines · Charles Manning
Quoted 17 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 5 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
Quoted 8 lines
This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Quoted 7 lines
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Thanks in advance for enlightening us as to what is going on here, David Daney
Quoted 8 lines
We are not working together on this, but I do appreciate the effort in helping
bring to a head what people like/dislike.I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so
that it is easier to add changes from yaffs.net.
Quoted 8 lines
Great. Thanks for clearing things up.
I will offer my unsolicited opinion:
Charles has obviously expended great effort on yaffs2. He has a git repository hosting the code, and has expressed a desire to get the code fit for merging. For Tracey Dent to come along and hijack the entire effort, would anger me if I were in Charles' place.
I didn't mean to hijack, I was just trying to help. :(
Quoted 4 lines
Having used yaffs2 in the past, I would like to see the code in the kernel. Having it come via Charles would seem to make sense.
But regardless it shouldn't matter who submitted the patches, as long as we can get it into mainline.
Quoted 2 lines
David Daney
Tracey Dent
Quoted 49 lines · Tracey Dent
Quoted 36 lines · David Daney
Quoted 26 lines · Charles Manning
Quoted 17 lines · On Tuesday 02 November 2010 07:55:39 David Daney wrote:
Quoted 5 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory. It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.
Quoted 8 lines
This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
Thanks,
Tracey Dent
I am confused.
Quoted 7 lines
Are you and Charles Manning working together on this?
Did you write all this code or did Charles? If it was Charles, why are there no From: and Signed-off-by headers for him?
Thanks in advance for enlightening us as to what is going on here, David Daney
Quoted 8 lines
We are not working together on this, but I do appreciate the effort in helping
bring to a head what people like/dislike.I am trying to keep the kernel yaffs consistent with the yaffs.net yaffs so
that it is easier to add changes from yaffs.net.Quoted 8 lines
Great. Thanks for clearing things up.
I will offer my unsolicited opinion:
Charles has obviously expended great effort on yaffs2. He has a git repository hosting the code, and has expressed a desire to get the code fit for merging. For Tracey Dent to come along and hijack the entire effort, would anger me if I were in Charles' place.
I didn't mean to hijack, I was just trying to help. :(
Quoted 1 line
Quoted 6 lines
Quoted 3 lines
Having used yaffs2 in the past, I would like to see the code in the kernel. Having it come via Charles would seem to make sense.
But regardless it shouldn't matter who submitted the patches, as long as we can get it into mainline.
In the very real world we live in, proper attribution of kernel patch authorship can make a concrete difference in employment decisions. And even without the monetary considerations, the health of the 'ecosystem' in which we operate is damaged if credit is not granted where due.
David Daney
Quoted 8 lines · Tracey Dent
The patch sets puts the yaffs2 filesystem in the staging directory.
It is all based on Charles git tree(http://github.com/cdhmanning/linux-yaffs-integration/). Everything is compile tested and it builds.This only the inital support and I will be sending more cleanup patches.
Greg can you add the patch set into your staging-next tree. Also, It doesn't affect anything other than itself.
I know Greg is happy to take this in but it would also be interesting to know what's the benefit of YAFFS2 over existing filesystems.