U-Boot

Download

u-boot@lists2.denx.biz

May 2012

175 participants
506 discussions

[U-Boot] [PATCH 1/2 V2] PMIC: MAX77686: Add support for MAX77686
by Rajeshwari Shinde 24 Aug '12

24 Aug '12

This patch adds driver and register definitions for PMIC chip MAX77686. Signed-off-by: Rajeshwari Shinde <rajeshwari.s(a)samsung.com> --- changes for V2: - using the generic PMIC framework instead of writing separate driver. drivers/misc/Makefile | 1 + drivers/misc/pmic_max77686.c | 42 +++++++++++ include/max77686_pmic.h | 158 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 201 insertions(+), 0 deletions(-) create mode 100644 drivers/misc/pmic_max77686.c create mode 100644 include/max77686_pmic.h diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile index 271463c..9fac190 100644 --- a/drivers/misc/Makefile +++ b/drivers/misc/Makefile @@ -39,6 +39,7 @@ COBJS-$(CONFIG_DIALOG_PMIC) += pmic_dialog.o COBJS-$(CONFIG_PMIC_FSL) += pmic_fsl.o COBJS-$(CONFIG_PMIC_I2C) += pmic_i2c.o COBJS-$(CONFIG_PMIC_SPI) += pmic_spi.o +COBJS-$(CONFIG_PMIC_MAX77686) += pmic_max77686.o COBJS-$(CONFIG_PMIC_MAX8998) += pmic_max8998.o COBJS-$(CONFIG_PMIC_MAX8997) += pmic_max8997.o diff --git a/drivers/misc/pmic_max77686.c b/drivers/misc/pmic_max77686.c new file mode 100644 index 0000000..36f7f4d --- /dev/null +++ b/drivers/misc/pmic_max77686.c @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2012 Samsung Electronics + * Rajeshwari Shinde <rajeshwari.s(a)samsung.com> + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#include <common.h> +#include <pmic.h> +#include <max77686_pmic.h> + +int pmic_init(void) +{ + struct pmic *p = get_pmic(); + static const char name[] = "MAX77686_PMIC"; + + puts("Board PMIC init\n"); + p->name = name; + p->interface = PMIC_I2C; + p->number_of_regs = PMIC_NUM_OF_REGS; + p->hw.i2c.addr = MAX77686_I2C_ADDR; + p->hw.i2c.tx_num = 1; + p->bus = I2C_PMIC; + + return 0; +} diff --git a/include/max77686_pmic.h b/include/max77686_pmic.h new file mode 100644 index 0000000..d949ace --- /dev/null +++ b/include/max77686_pmic.h @@ -0,0 +1,158 @@ +/* + * Copyright (C) 2012 Samsung Electronics + * Rajeshwari Shinde <rajeshwari.s(a)samsung.com> + * + * See file CREDITS for list of people who contributed to this + * project. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + */ + +#ifndef __MAX77686_H_ +#define __MAX77686_H_ + +enum { + MAX77686_REG_PMIC_ID = 0x0, + MAX77686_REG_PMIC_INTSRC, + MAX77686_REG_PMIC_INT1, + MAX77686_REG_PMIC_INT2, + MAX77686_REG_PMIC_INT1MSK, + MAX77686_REG_PMIC_INT2MSK, + + MAX77686_REG_PMIC_STATUS1, + MAX77686_REG_PMIC_STATUS2, + + MAX77686_REG_PMIC_PWRON, + MAX77686_REG_PMIC_ONOFFDELAY, + MAX77686_REG_PMIC_MRSTB, + + MAX77686_REG_PMIC_BUCK1CRTL = 0x10, + MAX77686_REG_PMIC_BUCK1OUT, + MAX77686_REG_PMIC_BUCK2CTRL1, + MAX77686_REG_PMIC_BUCK234FREQ, + MAX77686_REG_PMIC_BUCK2DVS1, + MAX77686_REG_PMIC_BUCK2DVS2, + MAX77686_REG_PMIC_BUCK2DVS3, + MAX77686_REG_PMIC_BUCK2DVS4, + MAX77686_REG_PMIC_BUCK2DVS5, + MAX77686_REG_PMIC_BUCK2DVS6, + MAX77686_REG_PMIC_BUCK2DVS7, + MAX77686_REG_PMIC_BUCK2DVS8, + MAX77686_REG_PMIC_BUCK3CTRL, + MAX77686_REG_PMIC_BUCK3DVS1, + MAX77686_REG_PMIC_BUCK3DVS2, + MAX77686_REG_PMIC_BUCK3DVS3, + MAX77686_REG_PMIC_BUCK3DVS4, + MAX77686_REG_PMIC_BUCK3DVS5, + MAX77686_REG_PMIC_BUCK3DVS6, + MAX77686_REG_PMIC_BUCK3DVS7, + MAX77686_REG_PMIC_BUCK3DVS8, + MAX77686_REG_PMIC_BUCK4CTRL1, + MAX77686_REG_PMIC_BUCK4DVS1 = 0x28, + MAX77686_REG_PMIC_BUCK4DVS2, + MAX77686_REG_PMIC_BUCK4DVS3, + MAX77686_REG_PMIC_BUCK4DVS4, + MAX77686_REG_PMIC_BUCK4DVS5, + MAX77686_REG_PMIC_BUCK4DVS6, + MAX77686_REG_PMIC_BUCK4DVS7, + MAX77686_REG_PMIC_BUCK4DVS8, + MAX77686_REG_PMIC_BUCK5CTRL, + MAX77686_REG_PMIC_BUCK5OUT, + MAX77686_REG_PMIC_BUCK6CRTL, + MAX77686_REG_PMIC_BUCK6OUT, + MAX77686_REG_PMIC_BUCK7CRTL, + MAX77686_REG_PMIC_BUCK7OUT, + MAX77686_REG_PMIC_BUCK8CRTL, + MAX77686_REG_PMIC_BUCK8OUT, + MAX77686_REG_PMIC_BUCK9CRTL, + MAX77686_REG_PMIC_BUCK9OUT, + + MAX77686_REG_PMIC_LDO1CTRL1 = 0x40, + MAX77686_REG_PMIC_LDO2CTRL1, + MAX77686_REG_PMIC_LDO3CTRL1, + MAX77686_REG_PMIC_LDO4CTRL1, + MAX77686_REG_PMIC_LDO5CTRL1, + MAX77686_REG_PMIC_LDO6CTRL1, + MAX77686_REG_PMIC_LDO7CTRL1, + MAX77686_REG_PMIC_LDO8CTRL1, + MAX77686_REG_PMIC_LDO9CTRL1, + MAX77686_REG_PMIC_LDO10CTRL1, + MAX77686_REG_PMIC_LDO11CTRL1, + MAX77686_REG_PMIC_LDO12CTRL1, + MAX77686_REG_PMIC_LDO13CTRL1, + MAX77686_REG_PMIC_LDO14CTRL1, + MAX77686_REG_PMIC_LDO15CTRL1, + MAX77686_REG_PMIC_LDO16CTRL1, + MAX77686_REG_PMIC_LDO17CTRL1, + MAX77686_REG_PMIC_LDO18CTRL1, + MAX77686_REG_PMIC_LDO19CTRL1, + MAX77686_REG_PMIC_LDO20CTRL1, + MAX77686_REG_PMIC_LDO21CTRL1, + MAX77686_REG_PMIC_LDO22CTRL1, + MAX77686_REG_PMIC_LDO23CTRL1, + MAX77686_REG_PMIC_LDO24CTRL1, + MAX77686_REG_PMIC_LDO25CTRL1, + MAX77686_REG_PMIC_LDO26CTRL1, + MAX77686_REG_PMIC_LDO1CTRL2, + MAX77686_REG_PMIC_LDO2CTRL2, + MAX77686_REG_PMIC_LDO3CTRL2, + MAX77686_REG_PMIC_LDO4CTRL2, + MAX77686_REG_PMIC_LDO5CTRL2, + MAX77686_REG_PMIC_LDO6CTRL2, + MAX77686_REG_PMIC_LDO7CTRL2, + MAX77686_REG_PMIC_LDO8CTRL2, + MAX77686_REG_PMIC_LDO9CTRL2, + MAX77686_REG_PMIC_LDO10CTRL2, + MAX77686_REG_PMIC_LDO11CTRL2, + MAX77686_REG_PMIC_LDO12CTRL2, + MAX77686_REG_PMIC_LDO13CTRL2, + MAX77686_REG_PMIC_LDO14CTRL2, + MAX77686_REG_PMIC_LDO15CTRL2, + MAX77686_REG_PMIC_LDO16CTRL2, + MAX77686_REG_PMIC_LDO17CTRL2, + MAX77686_REG_PMIC_LDO18CTRL2, + MAX77686_REG_PMIC_LDO19CTRL2, + MAX77686_REG_PMIC_LDO20CTRL2, + MAX77686_REG_PMIC_LDO21CTRL2, + MAX77686_REG_PMIC_LDO22CTRL2, + MAX77686_REG_PMIC_LDO23CTRL2, + MAX77686_REG_PMIC_LDO24CTRL2, + MAX77686_REG_PMIC_LDO25CTRL2, + MAX77686_REG_PMIC_LDO26CTRL2, + + MAX77686_REG_PMIC_BBAT = 0x7e, + MAX77686_REG_PMIC_32KHZ, + + PMIC_NUM_OF_REGS, +}; + +/* I2C device address for pmic max77686 */ +#define MAX77686_I2C_ADDR (0x12 >> 1) + +enum { + REG_DISABLE = 0, + REG_ENABLE +}; + +enum { + LDO_OFF = 0, + LDO_ON, + + DIS_LDO = (0x00 << 6), + EN_LDO = (0x3 << 6), +}; + +#endif /* __MAX77686_PMIC_H_ */ -- 1.7.4.4

5 9

[U-Boot] [PATCH] mkconfig: add support for SPL CPU
by Allen Martin 15 Aug '12

15 Aug '12

Add support for specifying a differnt CPU for main u-boot and SPL u-boot builds. This is done by adding an optional SPL CPU after the main CPU in boards.cfg as follows: normal_cpu:spl_cpu This this case CPU will be set to "normal_cpu" during the main u-boot build and "spl_cpu" during the SPL build. Signed-off-by: Allen Martin <amartin(a)nvidia.com> --- This is part of my patch series to move all armv4t code out of tegra u-boot to an SPL. I haven't heard any suggestions on how to resolve having a different CPU for the SPL build, so this is my suggestion as a possible solution. boards.cfg | 5 +++++ doc/README.SPL | 12 ++++++++++++ mkconfig | 15 ++++++++++++++- 3 files changed, 31 insertions(+), 1 deletions(-) diff --git a/boards.cfg b/boards.cfg index 3cf75c3..a58cd02 100644 --- a/boards.cfg +++ b/boards.cfg @@ -11,6 +11,11 @@ # Lines starting with '#' are comments. # Blank lines are ignored. # +# The CPU field takes the form: +# cpu[:spl_cpu] +# If spl_cpu is specified the make variable CPU will be set to this +# during the SPL build. +# # The options field takes the form: # <board config name>[:comma separated config options] # Each config option has the form (value defaults to "1"): diff --git a/doc/README.SPL b/doc/README.SPL index 0276953..e4a5ac3 100644 --- a/doc/README.SPL +++ b/doc/README.SPL @@ -66,3 +66,15 @@ CONFIG_SPL_DMA_SUPPORT (drivers/dma/libdma.o) CONFIG_SPL_POST_MEM_SUPPORT (post/drivers/memory.o) CONFIG_SPL_NAND_LOAD (drivers/mtd/nand/nand_spl_load.o) CONFIG_SPL_SPI_LOAD (drivers/mtd/spi/spi_spl_load.o) + + +Normally CPU is assumed to be the same between the SPL and normal +u-boot build. However it is possible to specify a different CPU for +the SPL build for cases where the SPL is expected to run on a +different CPU model from the main u-boot. This is done by specifying +an SPL CPU in boards.cfg as follows: + + normal_cpu:spl_cpu + +This this case CPU will be set to "normal_cpu" during the main u-boot +build and "spl_cpu" during the SPL build. diff --git a/mkconfig b/mkconfig index 438530b..82660a6 100755 --- a/mkconfig +++ b/mkconfig @@ -60,6 +60,11 @@ CONFIG_NAME="${1%_config}" arch="$2" cpu="$3" +tmp="${cpu#*:}" +if [ "$tmp" != "$cpu" ] ; then + spl_cpu=$tmp + cpu="${cpu%:*}" +fi if [ "$4" = "-" ] ; then board=${BOARD_NAME} else @@ -131,7 +136,15 @@ fi # Create include file for Make # echo "ARCH = ${arch}" > config.mk -echo "CPU = ${cpu}" >> config.mk +if [ ! -z "$spl_cpu" ] ; then + echo 'ifeq ($(CONFIG_SPL_BUILD),y)' >> config.mk + echo "CPU = ${spl_cpu}" >> config.mk + echo "else" >> config.mk + echo "CPU = ${cpu}" >> config.mk + echo "endif" >> config.mk +else + echo "CPU = ${cpu}" >> config.mk +fi echo "BOARD = ${board}" >> config.mk [ "${vendor}" ] && echo "VENDOR = ${vendor}" >> config.mk -- 1.7.5.4

2 2

[U-Boot] [PATCH 2/2] ext4fs write support
by uma.shankar＠samsung.com 13 Aug '12

13 Aug '12

From: Uma Shankar <uma.shankar(a)samsung.com> Signed-off-by: Uma Shankar <uma.shankar(a)samsung.com> Signed-off-by: Manjunatha C Achar <a.manjunatha(a)samsung.com> Signed-off-by: Iqbal Shareef <iqbal.ams(a)samsung.com> Signed-off-by: Hakgoo Lee <goodguy.lee(a)samsung.com> --- common/cmd_ext4.c | 135 +++++ fs/ext4/Makefile | 2 +- fs/ext4/crc16.c | 62 +++ fs/ext4/crc16.h | 16 + fs/ext4/ext4_common.c | 1386 +++++++++++++++++++++++++++++++++++++++++++++++- fs/ext4/ext4_common.h | 17 + fs/ext4/ext4_journal.c | 650 +++++++++++++++++++++++ fs/ext4/ext4_journal.h | 147 +++++ fs/ext4/ext4fs.c | 1038 ++++++++++++++++++++++++++++++++++++- include/ext4fs.h | 8 + 10 files changed, 3457 insertions(+), 4 deletions(-) create mode 100644 fs/ext4/crc16.c create mode 100644 fs/ext4/crc16.h create mode 100644 fs/ext4/ext4_journal.c create mode 100644 fs/ext4/ext4_journal.h diff --git a/common/cmd_ext4.c b/common/cmd_ext4.c index 7c2d541..781c6fe 100644 --- a/common/cmd_ext4.c +++ b/common/cmd_ext4.c @@ -47,11 +47,53 @@ uint64_t total_sector; uint64_t part_offset; +static unsigned long part_size; +static int cur_part = 1; #define DOS_PART_MAGIC_OFFSET 0x1fe #define DOS_FS_TYPE_OFFSET 0x36 #define DOS_FS32_TYPE_OFFSET 0x52 +static int ext4_register_device(block_dev_desc_t *dev_desc, int part_no) +{ + unsigned char buffer[SECTOR_SIZE]; + disk_partition_t info; + + if (!dev_desc->block_read) + return -1; + + /* check if we have a MBR (on floppies we have only a PBR) */ + if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *) buffer) != 1) { + printf("** Can't read from device %d **\n", dev_desc->dev); + return -1; + } + if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 || + buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) { + /* no signature found */ + return -1; + } + + /* First we assume there is a MBR */ + if (!get_partition_info(dev_desc, part_no, &info)) { + part_offset = info.start; + cur_part = part_no; + part_size = info.size; + } else if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET], + "FAT", 3) == 0) || (strncmp((char *)&buffer + [DOS_FS32_TYPE_OFFSET], + "FAT32", 5) == 0)) { + /* ok, we assume we are on a PBR only */ + cur_part = 1; + part_offset = 0; + } else { + printf("** Partition %d not valid on device %d **\n", + part_no, dev_desc->dev); + return -1; + } + + return 0; +} + int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { char *filename = NULL; @@ -241,6 +283,94 @@ int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) return 0; } +int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) +{ + char *filename = "/"; + int part_length; + unsigned long part = 1; + int dev = 0; + char *ep; + unsigned long ram_address; + unsigned long file_size; + disk_partition_t info; + struct ext_filesystem *fs; + + if (argc < 6) + return cmd_usage(cmdtp); + + dev = (int)simple_strtoul(argv[2], &ep, 16); + ext4_dev_desc = get_dev(argv[1], dev); + if (ext4_dev_desc == NULL) { + printf("Block device %s %d not" + "supported\n", argv[1], dev); + return 1; + } + if (init_fs(ext4_dev_desc)) + return 1; + + fs = get_fs(); + if (*ep) { + if (*ep != ':') { + puts("Invalid boot device, use `dev[:part]'\n"); + goto fail; + } + (int)strict_strtoul(++ep, 16, &part); + } + + /*get the filename */ + filename = argv[3]; + + /*get the address in hexadecimal format (string to int) */ + strict_strtoul(argv[4], 16, &ram_address); + + /*get the filesize in base 10 format */ + strict_strtoul(argv[5], 10, &file_size); + + /*set the device as block device */ + part_length = ext2fs_set_blk_dev(fs->dev_desc, part); + if (part_length == 0) { + printf("Bad partition - %s %d:%lu\n", argv[1], dev, part); + goto fail; + } + + /*register the device and partition */ + if (ext4_register_device(fs->dev_desc, part) != 0) { + printf("Unable to use %s %d:%lu for fattable\n", + argv[1], dev, part); + goto fail; + } + + /*get the partition information */ + if (!get_partition_info(fs->dev_desc, part, &info)) { + total_sector = (info.size * info.blksz) / SECTOR_SIZE; + fs->total_sect = total_sector; + } else { + printf("error : get partition info\n"); + goto fail; + } + + /*mount the filesystem */ + if (!ext4fs_mount(part_length)) { + printf("Bad ext4 partition %s %d:%lu\n", argv[1], dev, part); + goto fail; + } + + /*start write */ + if (ext4fs_write(filename, (unsigned char *)ram_address, file_size)) { + printf("** Error ext4fs_write() **\n"); + goto fail; + } + + ext4fs_close(); + deinit_fs(fs->dev_desc); + return 0; + +fail: + ext4fs_close(); + deinit_fs(fs->dev_desc); + return 1; +} + U_BOOT_CMD(ext4ls, 4, 1, do_ext4_ls, "list files in a directory (default /)", "<interface> <dev[:part]> [directory]\n" @@ -251,3 +381,8 @@ U_BOOT_CMD(ext4load, 6, 0, do_ext4_load, "<interface> <dev[:part]> [addr] [filename] [bytes]\n" " - load binary file 'filename' from 'dev' on 'interface'\n" " to address 'addr' from ext2 filesystem"); +U_BOOT_CMD + (ext4write, 6, 1, do_ext4_write, + "create a file in the root directory", + "<interface> <dev[:part]> [Absolute filename path] [Address] [sizebytes]\n" + " - create a file in / directory"); diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile index 850f821..1e7e7a8 100644 --- a/fs/ext4/Makefile +++ b/fs/ext4/Makefile @@ -30,7 +30,7 @@ include $(TOPDIR)/config.mk LIB = $(obj)libext4fs.o AOBJS = -COBJS-$(CONFIG_CMD_EXT4) := ext4fs.o ext4_common.o +COBJS-$(CONFIG_CMD_EXT4) := ext4fs.o ext4_common.o ext4_journal.o crc16.o SRCS := $(AOBJS:.o=.S) $(COBJS-y:.o=.c) OBJS := $(addprefix $(obj),$(AOBJS) $(COBJS-y)) diff --git a/fs/ext4/crc16.c b/fs/ext4/crc16.c new file mode 100644 index 0000000..3afb34d --- /dev/null +++ b/fs/ext4/crc16.c @@ -0,0 +1,62 @@ +/* + * crc16.c + * + * This source code is licensed under the GNU General Public License, + * Version 2. See the file COPYING for more details. + */ + +#include <common.h> +#include <asm/byteorder.h> +#include <linux/stat.h> +#include "crc16.h" + +/** CRC table for the CRC-16. The poly is 0x8005 (x16 + x15 + x2 + 1) */ +static __u16 const crc16_table[256] = { + 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, + 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, + 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, + 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, + 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, + 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, + 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, + 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, + 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, + 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, + 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, + 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, + 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, + 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, + 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, + 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, + 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, + 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, + 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, + 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, + 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, + 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, + 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, + 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, + 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, + 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, + 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, + 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, + 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, + 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, + 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, + 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 +}; + +/** + * Compute the CRC-16 for the data buffer +*/ + +unsigned int ext2fs_crc16(unsigned int crc, + const void *buffer, unsigned int len) +{ + const unsigned char *cp = buffer; + + while (len--) + crc = (((crc >> 8) & 0xffU) ^ + crc16_table[(crc ^ *cp++) & 0xffU]) & 0x0000ffffU; + return crc; +} diff --git a/fs/ext4/crc16.h b/fs/ext4/crc16.h new file mode 100644 index 0000000..5fd113a --- /dev/null +++ b/fs/ext4/crc16.h @@ -0,0 +1,16 @@ +/* + * crc16.h - CRC-16 routine + * Implements the standard CRC-16: + * Width 16 + * Poly 0x8005 (x16 + x15 + x2 + 1) + * Init 0 + * + * Copyright (c) 2005 Ben Gardner <bgardner(a)wabtec.com> + * This source code is licensed under the GNU General Public License, + * Version 2. See the file COPYING for more details. + */ +#ifndef __CRC16_H +#define __CRC16_H +extern unsigned int ext2fs_crc16(unsigned int crc, + const void *buffer, unsigned int len); +#endif diff --git a/fs/ext4/ext4_common.c b/fs/ext4/ext4_common.c index 6f9351c..29b578d 100644 --- a/fs/ext4/ext4_common.c +++ b/fs/ext4/ext4_common.c @@ -22,7 +22,13 @@ /* * ext4load - based on code from GRUB2 fs/ext2.c -*/ + * + * ext4write - based on existing ext2 support in UBOOT and ext4 + * implementation in Linux Kernel + * Journaling feature of ext4 has been referred from JBD2 + * (Journaling Block device 2) implementation in Linux Kernel + */ + #include <common.h> #include <ext_common.h> #include <ext4fs.h> @@ -30,7 +36,8 @@ #include <asm/byteorder.h> #include <linux/stat.h> #include <linux/time.h> -#include "ext4_common.h" +#include "crc16.h" +#include "ext4_journal.h" struct ext2_data *ext4fs_root; struct ext2fs_node *ext4fs_file; @@ -65,6 +72,834 @@ void *xzalloc(size_t size) return ptr; } +uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n) +{ + uint32_t res = size / n; + if (res * n != size) + res++; + return res; +} + +/* To convert big endian journal superblock entries to little endian */ +unsigned int be_le(unsigned int num) +{ + unsigned int swapped; + swapped = (((num >> 24) & 0xff) | + ((num << 8) & 0xff0000) | + ((num >> 8) & 0xff00) | ((num << 24) & 0xff000000)); + return swapped; +} + +/* 4-byte number*/ +unsigned int le_be(unsigned int num) +{ + return ((num & 0xff) << 24) + ((num & 0xff00) << 8) + + ((num & 0xff0000) >> 8) + ((num >> 24) & 0xff); +} + +void put_ext4(uint64_t off, void *buf, uint32_t size) +{ + uint64_t startblock, remainder; + short sector_size = 512; + unsigned char *temp_ptr = NULL; + char sec_buf[SECTOR_SIZE]; + struct ext_filesystem *fs = get_fs(); + + startblock = off / (uint64_t) sector_size; + startblock += part_offset; + remainder = off % (uint64_t) sector_size; + remainder &= SECTOR_SIZE - 1; + + if (fs->dev_desc == NULL) + return; + + if ((startblock + (size / SECTOR_SIZE)) > + (part_offset + fs->total_sect)) { + printf("part_offset is %lu\n", part_offset); + printf("total_sector is %llu\n", fs->total_sect); + printf("error: overflow occurs\n"); + return; + } + + if (remainder) { + if (fs->dev_desc->block_read) { + fs->dev_desc->block_read(fs->dev_desc->dev, + startblock, 1, + (unsigned char *)sec_buf); + temp_ptr = (unsigned char *)sec_buf; + memcpy((temp_ptr + remainder), + (unsigned char *)buf, size); + fs->dev_desc->block_write(fs->dev_desc->dev, + startblock, 1, + (unsigned char *)sec_buf); + } + } else { + if (size / SECTOR_SIZE != 0) { + fs->dev_desc->block_write(fs->dev_desc->dev, + startblock, + size / SECTOR_SIZE, + (unsigned long *)buf); + } else { + fs->dev_desc->block_read(fs->dev_desc->dev, + startblock, 1, + (unsigned char *)sec_buf); + temp_ptr = (unsigned char *)sec_buf; + memcpy(temp_ptr, buf, size); + fs->dev_desc->block_write(fs->dev_desc->dev, + startblock, 1, + (unsigned long *)sec_buf); + } + } + return; +} + +static int _get_new_inode_no(unsigned char *buffer) +{ + struct ext_filesystem *fs = get_fs(); + unsigned char input; + int operand, status, count = 1, j = 0; + + /*get the blocksize of the filesystem */ + unsigned char *ptr = buffer; + while (*ptr == 255) { + ptr++; + count += 8; + if (count > (uint32_t) ext4fs_root->sblock.inodes_per_group) + return -1; + } + + for (j = 0; j < fs->blksz; j++) { + input = *ptr; + int i = 0; + while (i <= 7) { + operand = 1 << i; + status = input & operand; + if (status) { + i++; + count++; + } else { + *ptr |= operand; + return count; + } + } + ptr = ptr + 1; + } + return -1; +} + +static int _get_new_blk_no(unsigned char *buffer) +{ + unsigned char input; + int operand, status, count = 0, j = 0; + unsigned char *ptr = buffer; + struct ext_filesystem *fs = get_fs(); + + if (fs->blksz != 1024) + count = 0; + else + count = 1; + + while (*ptr == 255) { + ptr++; + count += 8; + if (count == (fs->blksz * 8)) + return -1; + } + + for (j = 0; j < fs->blksz; j++) { + input = *ptr; + int i = 0; + while (i <= 7) { + operand = 1 << i; + status = input & operand; + if (status) { + i++; + count++; + } else { + *ptr |= operand; + return count; + } + } + ptr = ptr + 1; + } + return -1; +} + +int set_block_bmap(long int blockno, unsigned char *buffer, int index) +{ + int i, remainder, status; + unsigned char *ptr = buffer; + unsigned char operand; + i = blockno / 8; + remainder = blockno % 8; + int blocksize = EXT2_BLOCK_SIZE(ext4fs_root); + + i = i - (index * blocksize); + if (blocksize != 1024) { + ptr = ptr + i; + operand = 1 << remainder; + status = *ptr & operand; + if (status) + return -1; + else { + *ptr = *ptr | operand; + return 0; + } + } else { + if (remainder == 0) { + ptr = ptr + i - 1; + operand = (1 << 7); + } else { + ptr = ptr + i; + operand = (1 << (remainder - 1)); + } + status = *ptr & operand; + if (status) + return -1; + else { + *ptr = *ptr | operand; + return 0; + } + } +} + +void reset_block_bmap(long int blockno, unsigned char *buffer, int index) +{ + int i, remainder, status; + unsigned char *ptr = buffer; + unsigned char operand; + i = blockno / 8; + remainder = blockno % 8; + int blocksize = EXT2_BLOCK_SIZE(ext4fs_root); + + i = i - (index * blocksize); + if (blocksize != 1024) { + ptr = ptr + i; + operand = (1 << remainder); + status = *ptr & operand; + if (status) + *ptr = *ptr & ~(operand); + } else { + if (remainder == 0) { + ptr = ptr + i - 1; + operand = (1 << 7); + } else { + ptr = ptr + i; + operand = (1 << (remainder - 1)); + } + status = *ptr & operand; + if (status) + *ptr = *ptr & ~(operand); + } + return; +} + +int set_inode_bmap(int inode_no, unsigned char *buffer, int index) +{ + int i, remainder, status; + unsigned char *ptr = buffer; + unsigned char operand; + + inode_no -= (index * (uint32_t) ext4fs_root->sblock.inodes_per_group); + i = inode_no / 8; + remainder = inode_no % 8; + if (remainder == 0) { + ptr = ptr + i - 1; + operand = (1 << 7); + } else { + ptr = ptr + i; + operand = (1 << (remainder - 1)); + } + status = *ptr & operand; + if (status) + return -1; + else { + *ptr = *ptr | operand; + return 0; + } +} + +void reset_inode_bmap(int inode_no, unsigned char *buffer, int index) +{ + int i, remainder, status; + unsigned char *ptr = buffer; + unsigned char operand; + + inode_no -= (index * (uint32_t) ext4fs_root->sblock.inodes_per_group); + i = inode_no / 8; + remainder = inode_no % 8; + if (remainder == 0) { + ptr = ptr + i - 1; + operand = (1 << 7); + } else { + ptr = ptr + i; + operand = (1 << (remainder - 1)); + } + status = *ptr & operand; + if (status) + *ptr = *ptr & ~(operand); + return; +} + +int ext4fs_checksum_update(unsigned int i) +{ + struct ext2_block_group *desc; + struct ext_filesystem *fs = get_fs(); + __u16 crc = 0; + + desc = (struct ext2_block_group *)&fs->gd[i]; + if (fs->sb->feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { + int offset = offsetof(struct ext2_block_group, bg_checksum); + + crc = ext2fs_crc16(~0, fs->sb->unique_id, + sizeof(fs->sb->unique_id)); + crc = ext2fs_crc16(crc, &i, sizeof(i)); + crc = ext2fs_crc16(crc, desc, offset); + offset += sizeof(desc->bg_checksum); /* skip checksum */ + assert(offset == sizeof(*desc)); + } + return crc; +} + +static int check_void_in_dentry(struct ext2_dirent *dir, char *filename) +{ + int dentry_length = 0; + short padding_factor = 0; + int sizeof_void_space = 0; + int new_entry_byte_reqd = 0; + + if (dir->namelen % 4 != 0) + padding_factor = 4 - (dir->namelen % 4); + + dentry_length = sizeof(struct ext2_dirent) + + dir->namelen + padding_factor; + sizeof_void_space = dir->direntlen - dentry_length; + if (sizeof_void_space == 0) { + return 0; + } else { + padding_factor = 0; + if (strlen(filename) % 4 != 0) + padding_factor = 4 - (strlen(filename) % 4); + + new_entry_byte_reqd = strlen(filename) + + sizeof(struct ext2_dirent) + padding_factor; + if (sizeof_void_space >= new_entry_byte_reqd) { + dir->direntlen = dentry_length; + return sizeof_void_space; + } else + return 0; + } +} + +void update_parent_dentry(char *filename, int *p_ino, int file_type) +{ + unsigned int *zero_buffer = NULL; + char *root_first_block_buffer = NULL; + struct ext_filesystem *fs = get_fs(); + int direct_blk_idx; + long int root_blknr; + long int first_block_no_of_root = 0; + long int previous_blknr = -1; + int totalbytes = 0; + short int padding_factor = 0; + unsigned int new_entry_byte_reqd; + unsigned int last_entry_dirlen; + int sizeof_void_space = 0; + int templength = 0, inodeno, status; + /*directory entry */ + struct ext2_dirent *dir; + char *ptr = NULL; + char *temp_dir = NULL; + + /*##START: Update the root directory entry block of root inode ### */ + /*since we are populating this file under root + *directory take the root inode and its first block + *currently we are looking only in first block of root + *inode*/ + + zero_buffer = xzalloc(fs->blksz); + if (!zero_buffer) + return; + root_first_block_buffer = (char *)xzalloc(fs->blksz); + if (!root_first_block_buffer) + return; +RESTART: + + /*read the block no allocated to a file */ + for (direct_blk_idx = 0; direct_blk_idx < INDIRECT_BLOCKS; + direct_blk_idx++) { + root_blknr = read_allocated_block(g_parent_inode, + direct_blk_idx); + if (root_blknr == 0) { + first_block_no_of_root = previous_blknr; + break; + } + previous_blknr = root_blknr; + } + + status = ext2fs_devread(first_block_no_of_root + * fs->sect_perblk, + 0, fs->blksz, root_first_block_buffer); + if (status == 0) + goto fail; + else { + if (log_journal(root_first_block_buffer, + first_block_no_of_root)) + goto fail; + dir = (struct ext2_dirent *)root_first_block_buffer; + ptr = (char *)dir; + totalbytes = 0; + while (dir->direntlen > 0) { + /* blocksize-totalbytes because last directory length + * i.e. dir->direntlen is free availble space in the + * block that means it is a last entry of directory + * entry + */ + + /* traversing the each directory entry */ + if (fs->blksz - totalbytes == dir->direntlen) { + if (strlen(filename) % 4 != 0) + padding_factor = 4 - + (strlen(filename) % 4); + + new_entry_byte_reqd = strlen(filename) + + sizeof(struct ext2_dirent) + padding_factor; + padding_factor = 0; + /* update last directory entry length to its + * length because we are creating new directory + * entry */ + if (dir->namelen % 4 != 0) + padding_factor = 4 - (dir->namelen % 4); + + last_entry_dirlen = dir->namelen + + sizeof(struct ext2_dirent) + padding_factor; + if ((fs->blksz - totalbytes - last_entry_dirlen) + < new_entry_byte_reqd) { + printf("1st Block Full:" + "allocating new block\n"); + + if (direct_blk_idx == + INDIRECT_BLOCKS - 1) { + printf("Directory capacity" + "exceeds the limit\n"); + goto fail; + } + g_parent_inode->b.blocks.dir_blocks + [direct_blk_idx] = get_new_blk_no(); + if (g_parent_inode->b.blocks.dir_blocks + [direct_blk_idx] == -1) { + printf("no block" + "left to assign\n"); + goto fail; + } + put_ext4(((uint64_t) + (g_parent_inode->b.blocks. + dir_blocks[direct_blk_idx] * + fs->blksz)), zero_buffer, + fs->blksz); + g_parent_inode->size = + g_parent_inode->size + fs->blksz; + g_parent_inode->blockcnt = + g_parent_inode->blockcnt + + fs->sect_perblk; + if (put_metadata + (root_first_block_buffer, + first_block_no_of_root)) + goto fail; + goto RESTART; + } + dir->direntlen = last_entry_dirlen; + break; + } + + templength = dir->direntlen; + totalbytes = totalbytes + templength; + sizeof_void_space = check_void_in_dentry(dir, filename); + if (sizeof_void_space) + break; + + dir = (struct ext2_dirent *)((char *)dir + templength); + ptr = (char *)dir; + } + + /*make a pointer ready for creating next directory entry */ + templength = dir->direntlen; + totalbytes = totalbytes + templength; + dir = (struct ext2_dirent *)((char *)dir + templength); + ptr = (char *)dir; + + /*get the next available inode number */ + inodeno = get_new_inode_no(); + if (inodeno == -1) { + printf("no inode left to assign\n"); + goto fail; + } + dir->inode = inodeno; + if (sizeof_void_space) + dir->direntlen = sizeof_void_space; + else + dir->direntlen = fs->blksz - totalbytes; + dir->namelen = strlen(filename); + dir->filetype = FILETYPE_REG; /*regular file */ + temp_dir = (char *)dir; + temp_dir = temp_dir + sizeof(struct ext2_dirent); + memcpy(temp_dir, filename, strlen(filename)); + } + *p_ino = inodeno; + + /*update or write the 1st block of root inode */ + if (put_metadata(root_first_block_buffer, first_block_no_of_root)) + goto fail; + +fail: + if (zero_buffer) + free(zero_buffer); + if (root_first_block_buffer) + free(root_first_block_buffer); + + /*END: Update the root directory entry block of root inode */ +} + +static int search_dir(struct ext2_inode *parent_inode, char *dirname) +{ + unsigned char *block_buffer; + struct ext_filesystem *fs = get_fs(); + struct ext2_dirent *dir = NULL; + struct ext2_dirent *previous_dir = NULL; + int status, inodeno, totalbytes, templength, direct_blk_idx; + int found = 0; + char *ptr; + long int blknr; + + /*get the first block of root */ + /*read the block no allocated to a file */ + for (direct_blk_idx = 0; direct_blk_idx < INDIRECT_BLOCKS; + direct_blk_idx++) { + blknr = read_allocated_block(parent_inode, direct_blk_idx); + if (blknr == 0) + goto fail; + + /*read the blocks of parenet inode */ + block_buffer = xzalloc(fs->blksz); + if (!block_buffer) + goto fail; + + status = ext2fs_devread(blknr * fs->sect_perblk, + 0, fs->blksz, (char *)block_buffer); + if (status == 0) + goto fail; + else { + dir = (struct ext2_dirent *)block_buffer; + ptr = (char *)dir; + totalbytes = 0; + while (dir->direntlen >= 0) { + /*blocksize-totalbytes because last directory + *length i.e.,*dir->direntlen is free availble + *space in the block that means + *it is a last entry of directory entry + */ + if (strlen(dirname) == dir->namelen) { + if (strncmp(dirname, ptr + + sizeof(struct ext2_dirent), + dir->namelen) == 0) { + previous_dir->direntlen += + dir->direntlen; + inodeno = dir->inode; + dir->inode = 0; + found = 1; + break; + } + } + + if (fs->blksz - totalbytes == dir->direntlen) + break; + + /*traversing the each directory entry */ + templength = dir->direntlen; + totalbytes = totalbytes + templength; + previous_dir = dir; + dir = (struct ext2_dirent *)((char *)dir + + templength); + ptr = (char *)dir; + } + } + + if (found == 1) { + if (block_buffer) { + free(block_buffer); + block_buffer = NULL; + } + return inodeno; + } + + if (block_buffer) { + free(block_buffer); + block_buffer = NULL; + } + } + +fail: + if (block_buffer) { + free(block_buffer); + block_buffer = NULL; + } + return -1; +} + +static int find_dir_depth(char *dirname) +{ + char *token = strtok(dirname, "/"); + int count = 0; + while (token != NULL) { + token = strtok(NULL, "/"); + count++; + } + return count + 1 + 1; + /* + *for example for string /home/temp + *depth=home(1)+temp(1)+1 extra for NULL; + *so count is 4; + */ +} + +static int parse_path(char **arr, char *dirname) +{ + char *token = strtok(dirname, "/"); + int i = 0; + + /*add root */ + arr[i] = xzalloc(strlen("/") + 1); + if (!arr[i]) + return -1; + + arr[i++] = "/"; + + /*add each path entry after root */ + while (token != NULL) { + arr[i] = xzalloc(strlen(token) + 1); + if (!arr[i]) + return -1; + memcpy(arr[i++], token, strlen(token)); + token = strtok(NULL, "/"); + } + + arr[i] = NULL; + /*success */ + return 0; +} + +int iget(int inode_no, struct ext2_inode *inode) +{ + if (ext4fs_read_inode(ext4fs_root, inode_no, inode) == 0) + return -1; + else + return 0; +} + +/* +* Function:get_parent_inode_num +* Return Value: inode Number of the parent directory of file/Directory to be +* created +* dirname : Input parmater, input path name of the file/directory to be created +* dname : Output parameter, to be filled with the name of the directory +* extracted from dirname +*/ +int get_parent_inode_num(char *dirname, char *dname, int flags) +{ + char **ptr = NULL; + int i, depth = 0; + char *depth_dirname = NULL; + char *parse_dirname = NULL; + struct ext2_inode *parent_inode = NULL; + struct ext2_inode *first_inode = NULL; + struct ext2_inode temp_inode; + int matched_inode_no; + int result_inode_no = -1; + + if (*dirname != '/') { + printf("Please supply Absolute path\n"); + return -1; + } + + depth_dirname = (char *)xzalloc(strlen(dirname) + 1); + if (!depth_dirname) + return -1; + + memcpy(depth_dirname, dirname, strlen(dirname)); + depth = find_dir_depth(depth_dirname); + parse_dirname = (char *)xzalloc(strlen(dirname) + 1); + if (!parse_dirname) + goto fail; + memcpy(parse_dirname, dirname, strlen(dirname)); + + ptr = (char **)xzalloc((depth) * sizeof(char *)); + if (!ptr) + goto fail; + if (parse_path(ptr, parse_dirname)) + goto fail; + parent_inode = (struct ext2_inode *) + xzalloc(sizeof(struct ext2_inode)); + if (!parent_inode) + goto fail; + first_inode = (struct ext2_inode *) + xzalloc(sizeof(struct ext2_inode)); + if (!first_inode) + goto fail; + memcpy(parent_inode, ext4fs_root->inode, sizeof(struct ext2_inode)); + memcpy(first_inode, parent_inode, sizeof(struct ext2_inode)); + if (flags & F_FILE) + result_inode_no = EXT2_ROOT_INO; + for (i = 1; i < depth; i++) { + matched_inode_no = search_dir(parent_inode, ptr[i]); + if (matched_inode_no == -1) { + if (ptr[i + 1] == NULL && i == 1) { + result_inode_no = EXT2_ROOT_INO; + goto END; + } else { + if (ptr[i + 1] == NULL) + break; + printf("Invalid path\n"); + result_inode_no = -1; + goto fail; + } + } else { + if (ptr[i + 1] != NULL) { + memset(parent_inode, '\0', + sizeof(struct ext2_inode)); + if (iget(matched_inode_no, parent_inode)) { + result_inode_no = -1; + goto fail; + } + result_inode_no = matched_inode_no; + } else + break; + } + } + +END: + if (i == 1) + matched_inode_no = search_dir(first_inode, ptr[i]); + else + matched_inode_no = search_dir(parent_inode, ptr[i]); + + if (matched_inode_no != -1) { + iget(matched_inode_no, &temp_inode); + if (temp_inode.mode & S_IFDIR) { + printf("It is a Directory\n"); + result_inode_no = -1; + goto fail; + } + } + + if (strlen(ptr[i]) > 256) { + result_inode_no = -1; + goto fail; + } + memcpy(dname, ptr[i], strlen(ptr[i])); + +fail: + if (depth_dirname) + free(depth_dirname); + if (parse_dirname) + free(parse_dirname); + if (ptr) + free(ptr); + if (parent_inode) + free(parent_inode); + if (first_inode) + free(first_inode); + + return result_inode_no; +} + +static int check_filename(char *filename, unsigned int blknr) +{ + char *root_first_block_buffer, *root_first_block_addr; + unsigned int first_block_no_of_root; + struct ext_filesystem *fs = get_fs(); + struct ext2_dirent *dir; + struct ext2_dirent *previous_dir = NULL; + int totalbytes = 0; + int templength = 0; + int status, inodeno; + int found = 0; + char *ptr; + + first_block_no_of_root = blknr; + root_first_block_buffer = (char *)xzalloc(fs->blksz); + if (!root_first_block_buffer) + return -1; + root_first_block_addr = root_first_block_buffer; + status = ext2fs_devread(first_block_no_of_root * + fs->sect_perblk, 0, + fs->blksz, root_first_block_buffer); + if (status == 0) { + goto fail; + } else { + if (log_journal(root_first_block_buffer, + first_block_no_of_root)) + goto fail; + dir = (struct ext2_dirent *)root_first_block_buffer; + ptr = (char *)dir; + totalbytes = 0; + while (dir->direntlen >= 0) { + if (strlen(filename) == dir->namelen) { + if (strncmp(filename, + ptr + sizeof(struct ext2_dirent), + dir->namelen) == 0) { + printf("file found deleting\n"); + previous_dir->direntlen += + dir->direntlen; + inodeno = dir->inode; + dir->inode = 0; + found = 1; + break; + } + } + + if (fs->blksz - totalbytes == dir->direntlen) + break; + + /*traversing the each directory entry */ + templength = dir->direntlen; + totalbytes = totalbytes + templength; + previous_dir = dir; + dir = (struct ext2_dirent *)((char *)dir + templength); + ptr = (char *)dir; + } + } + + if (found == 1) { + if (put_metadata(root_first_block_addr, first_block_no_of_root)) + goto fail; + return inodeno; + } + +fail: + if (root_first_block_buffer) + free(root_first_block_buffer); + return -1; +} + +int ext4fs_filename_check(char *filename) +{ + short direct_blk_idx = 0; + long int blknr = -1; + int inodeno = -1; + + /*read the block no allocated to a file */ + for (direct_blk_idx = 0; direct_blk_idx < INDIRECT_BLOCKS; + direct_blk_idx++) { + blknr = read_allocated_block(g_parent_inode, direct_blk_idx); + if (blknr == 0) + break; + inodeno = check_filename(filename, blknr); + if (inodeno != -1) + return inodeno; + } + return -1; +} + static struct ext4_extent_header *ext4fs_find_leaf(struct ext2_data *data, char *buf, struct ext4_extent_header *ext_block, uint32_t fileblock) { @@ -152,6 +987,553 @@ int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode) return 1; } +long int get_new_blk_no(void) +{ + short i, status; + int remainder; + unsigned int bg_idx; + static int prev_bg_bitmap_index = -1; + struct ext_filesystem *fs = get_fs(); + char *journal_buffer = (char *)xzalloc(fs->blksz); + char *zero_buffer = (char *)xzalloc(fs->blksz); + if (!journal_buffer || !zero_buffer) + goto fail; + struct ext2_block_group *gd = (struct ext2_block_group *)fs->gdtable; + + if (fs->first_pass_bbmap == 0) { + for (i = 0; i < fs->no_blkgrp; i++) { + if (gd[i].free_blocks) { + if (gd[i].bg_flags & EXT4_BG_BLOCK_UNINIT) { + put_ext4(((uint64_t) (gd[i].block_id * + fs->blksz)), + zero_buffer, fs->blksz); + gd[i].bg_flags = + gd[i]. + bg_flags & ~EXT4_BG_BLOCK_UNINIT; + memcpy(fs->blk_bmaps[i], zero_buffer, + fs->blksz); + } + fs->curr_blkno = + _get_new_blk_no(fs->blk_bmaps[i]); + if (fs->curr_blkno == -1) { + /*if block bitmap is completely fill */ + continue; + } + fs->curr_blkno = fs->curr_blkno + + (i * fs->blksz * 8); + fs->first_pass_bbmap++; + gd[i].free_blocks--; + fs->sb->free_blocks--; + status = ext2fs_devread(gd[i].block_id * + fs->sect_perblk, 0, + fs->blksz, + journal_buffer); + if (status == 0) + goto fail; + if (log_journal(journal_buffer, gd[i].block_id)) + goto fail; + goto success; + } else { + debug("no space left on block group %d\n", i); + } + } + goto fail; + } else { +restart: + fs->curr_blkno++; + /*get the blockbitmap index respective to blockno */ + if (fs->blksz != 1024) { + bg_idx = fs->curr_blkno / + (uint32_t) ext4fs_root->sblock.blocks_per_group; + } else { + bg_idx = fs->curr_blkno / + (uint32_t) ext4fs_root->sblock.blocks_per_group; + remainder = fs->curr_blkno % + (uint32_t) ext4fs_root->sblock.blocks_per_group; + if (!remainder) + bg_idx--; + } + + if (bg_idx >= fs->no_blkgrp) + goto fail; + + if (gd[bg_idx].free_blocks == 0) { + debug("block group %u is full. Skipping\n", bg_idx); + fs->curr_blkno = fs->curr_blkno + + ext4fs_root->sblock.blocks_per_group; + fs->curr_blkno--; + goto restart; + } + + if (gd[bg_idx].bg_flags & EXT4_BG_BLOCK_UNINIT) { + memset(zero_buffer, '\0', fs->blksz); + put_ext4(((uint64_t) (gd[bg_idx].block_id * fs->blksz)), + zero_buffer, fs->blksz); + memcpy(fs->blk_bmaps[bg_idx], zero_buffer, fs->blksz); + gd[bg_idx].bg_flags = gd[bg_idx].bg_flags & + ~EXT4_BG_BLOCK_UNINIT; + } + + if (set_block_bmap(fs->curr_blkno, fs->blk_bmaps[bg_idx], + bg_idx) != 0) { + debug("going for restart for the block no %ld %u\n", + fs->curr_blkno, bg_idx); + goto restart; + } + + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + memset(journal_buffer, '\0', fs->blksz); + status = ext2fs_devread(gd[bg_idx].block_id + * fs->sect_perblk, + 0, fs->blksz, journal_buffer); + if (status == 0) + goto fail; + if (log_journal(journal_buffer, gd[bg_idx].block_id)) + goto fail; + + prev_bg_bitmap_index = bg_idx; + } + gd[bg_idx].free_blocks--; + fs->sb->free_blocks--; + goto success; + } +success: + if (journal_buffer) + free(journal_buffer); + if (zero_buffer) + free(zero_buffer); + return fs->curr_blkno; +fail: + if (journal_buffer) + free(journal_buffer); + if (zero_buffer) + free(zero_buffer); + return -1; +} + +int get_new_inode_no(void) +{ + short i, status; + unsigned int ibmap_idx; + static int prev_inode_bitmap_index = -1; + struct ext_filesystem *fs = get_fs(); + char *journal_buffer = (char *)xzalloc(fs->blksz); + char *zero_buffer = (char *)xzalloc(fs->blksz); + if (!journal_buffer || !zero_buffer) + goto fail; + struct ext2_block_group *gd = (struct ext2_block_group *)fs->gdtable; + + if (fs->first_pass_ibmap == 0) { + for (i = 0; i < fs->no_blkgrp; i++) { + if (gd[i].free_inodes) { + if (gd[i].bg_flags & EXT4_BG_INODE_UNINIT) { + put_ext4(((uint64_t) + (gd[i].inode_id * fs->blksz)), + zero_buffer, fs->blksz); + gd[i].bg_flags = gd[i].bg_flags & + ~EXT4_BG_INODE_UNINIT; + memcpy(fs->inode_bmaps[i], + zero_buffer, fs->blksz); + } + fs->curr_inode_no = + _get_new_inode_no(fs->inode_bmaps[i]); + if (fs->curr_inode_no == -1) { + /*if block bitmap is completely fill */ + continue; + } + fs->curr_inode_no = fs->curr_inode_no + + (i * ext4fs_root->sblock.inodes_per_group); + fs->first_pass_ibmap++; + gd[i].free_inodes--; + gd[i].bg_itable_unused--; + fs->sb->free_inodes--; + status = ext2fs_devread(gd[i].inode_id * + fs->sect_perblk, 0, + fs->blksz, + journal_buffer); + if (status == 0) + goto fail; + if (log_journal(journal_buffer, gd[i].inode_id)) + goto fail; + goto success; + } else + debug("no inode left on block group %d\n", i); + } + goto fail; + } else { +restart: + fs->curr_inode_no++; + /*get the blockbitmap index respective to blockno */ + ibmap_idx = fs->curr_inode_no / + (uint32_t) ext4fs_root->sblock.inodes_per_group; + if (gd[ibmap_idx].bg_flags & EXT4_BG_INODE_UNINIT) { + memset(zero_buffer, '\0', fs->blksz); + put_ext4(((uint64_t) (gd[ibmap_idx].inode_id * + fs->blksz)), zero_buffer, + fs->blksz); + gd[ibmap_idx].bg_flags = + gd[ibmap_idx].bg_flags & ~EXT4_BG_INODE_UNINIT; + memcpy(fs->inode_bmaps[ibmap_idx], zero_buffer, + fs->blksz); + } + + if (set_inode_bmap(fs->curr_inode_no, + fs->inode_bmaps[ibmap_idx], + ibmap_idx) != 0) { + debug("going for restart for the block no %d %u\n", + fs->curr_inode_no, ibmap_idx); + goto restart; + } + + /*journal backup */ + if (prev_inode_bitmap_index != ibmap_idx) { + memset(journal_buffer, '\0', fs->blksz); + status = ext2fs_devread(gd[ibmap_idx].inode_id + * fs->sect_perblk, + 0, fs->blksz, journal_buffer); + if (status == 0) + goto fail; + if (log_journal(journal_buffer, gd[ibmap_idx].inode_id)) + goto fail; + prev_inode_bitmap_index = ibmap_idx; + } + + gd[ibmap_idx].free_inodes--; + gd[ibmap_idx].bg_itable_unused--; + fs->sb->free_inodes--; + goto success; + } + +success: + if (journal_buffer) + free(journal_buffer); + if (zero_buffer) + free(zero_buffer); + return fs->curr_inode_no; + +fail: + if (journal_buffer) + free(journal_buffer); + if (zero_buffer) + free(zero_buffer); + return -1; + +} + +/*allocation of single indirect blocks*/ +static void alloc_single_indirect_block(struct ext2_inode *file_inode, + unsigned int *total_remaining_blocks, + unsigned int *no_blks_reqd) +{ + short i, status; + long int actual_block_no; + /*single indirect */ + unsigned int *SI_buffer = NULL; + long int SI_blockno; + unsigned int *SI_start_addr = NULL; + struct ext_filesystem *fs = get_fs(); + + if (*total_remaining_blocks != 0) { + SI_buffer = xzalloc(fs->blksz); + if (!SI_buffer) + return; + SI_start_addr = SI_buffer; + SI_blockno = get_new_blk_no(); + if (SI_blockno == -1) { + printf("no block left to assign\n"); + goto fail; + } + (*no_blks_reqd)++; + debug("SIPB %ld: %u\n", SI_blockno, *total_remaining_blocks); + + status = ext2fs_devread(SI_blockno * fs->sect_perblk, + 0, fs->blksz, (char *)SI_buffer); + memset(SI_buffer, '\0', fs->blksz); + if (status == 0) + goto fail; + + for (i = 0; i < (fs->blksz / sizeof(int)); i++) { + actual_block_no = get_new_blk_no(); + if (actual_block_no == -1) { + printf("no block left to assign\n"); + goto fail; + } + *SI_buffer = actual_block_no; + debug("SIAB %u: %u\n", *SI_buffer, + *total_remaining_blocks); + + SI_buffer++; + (*total_remaining_blocks)--; + if (*total_remaining_blocks == 0) + break; + } + + /*write the block to disk */ + put_ext4(((uint64_t) (SI_blockno * fs->blksz)), + SI_start_addr, fs->blksz); + file_inode->b.blocks.indir_block = SI_blockno; + } +fail: + if (SI_start_addr) + free(SI_start_addr); + return; +} + +/*allocation of double indirect blocks*/ +static void alloc_double_indirect_block(struct ext2_inode *file_inode, + unsigned int *total_remaining_blocks, + unsigned int *no_blks_reqd) +{ + short i, j, status; + long int actual_block_no; + /*double indirect */ + long int DI_blockno_parent, DI_blockno_child; + unsigned int *DI_parent_buffer = NULL; + unsigned int *DI_child_buff = NULL; + unsigned int *DI_block_start_addr = NULL; + unsigned int *DI_child_buff_start = NULL; + struct ext_filesystem *fs = get_fs(); + + if (*total_remaining_blocks != 0) { + /*double indirect parent block connecting to inode */ + DI_blockno_parent = get_new_blk_no(); + if (DI_blockno_parent == -1) { + printf("no block left to assign\n"); + goto fail; + } + DI_parent_buffer = xzalloc(fs->blksz); + if (!DI_parent_buffer) + goto fail; + + DI_block_start_addr = DI_parent_buffer; + (*no_blks_reqd)++; + debug("DIPB %ld: %u\n", DI_blockno_parent, + *total_remaining_blocks); + + status = ext2fs_devread(DI_blockno_parent * + fs->sect_perblk, 0, + fs->blksz, (char *)DI_parent_buffer); + memset(DI_parent_buffer, '\0', fs->blksz); + + /*START: for each double indirect parent + *block create one more block*/ + for (i = 0; i < (fs->blksz / sizeof(int)); i++) { + DI_blockno_child = get_new_blk_no(); + if (DI_blockno_child == -1) { + printf("no block left to assign\n"); + goto fail; + } + DI_child_buff = xzalloc(fs->blksz); + if (!DI_child_buff) + goto fail; + + DI_child_buff_start = DI_child_buff; + *DI_parent_buffer = DI_blockno_child; + DI_parent_buffer++; + (*no_blks_reqd)++; + debug("DICB %ld: %u\n", DI_blockno_child, + *total_remaining_blocks); + + status = ext2fs_devread(DI_blockno_child * + fs->sect_perblk, 0, + fs->blksz, + (char *)DI_child_buff); + memset(DI_child_buff, '\0', fs->blksz); + /*END: for each double indirect parent block block */ + /*filling of actual datablocks for each child */ + for (j = 0; j < (fs->blksz / sizeof(int)); j++) { + actual_block_no = get_new_blk_no(); + if (actual_block_no == -1) { + printf("no block left to assign\n"); + goto fail; + } + *DI_child_buff = actual_block_no; + debug("DIAB %ld: %u\n", actual_block_no, + *total_remaining_blocks); + + DI_child_buff++; + (*total_remaining_blocks)--; + if (*total_remaining_blocks == 0) + break; + } + /*write the block table */ + put_ext4(((uint64_t) (DI_blockno_child * fs->blksz)), + DI_child_buff_start, fs->blksz); + if (DI_child_buff_start) + free(DI_child_buff_start); + + if (*total_remaining_blocks == 0) + break; + } + put_ext4(((uint64_t) (DI_blockno_parent * fs->blksz)), + DI_block_start_addr, fs->blksz); + file_inode->b.blocks.double_indir_block = DI_blockno_parent; + } +fail: + if (DI_block_start_addr) + free(DI_block_start_addr); + return; +} + +/*allocation of triple indirect blocks*/ +static void alloc_triple_indirect_block(struct ext2_inode *file_inode, + unsigned int *total_remaining_blocks, + unsigned int *no_blks_reqd) +{ + short i, j, k; + long int actual_block_no; + /*Triple Indirect */ + long int TI_gp_blockno, TI_parent_blockno, TI_child_blockno; + unsigned int *TI_gp_buff = NULL; + unsigned int *TI_parent_buff = NULL; + unsigned int *TI_child_buff = NULL; + unsigned int *TI_gp_buff_start_addr = NULL; + unsigned int *TI_pbuff_start_addr = NULL; + unsigned int *TI_cbuff_start_addr = NULL; + struct ext_filesystem *fs = get_fs(); + if (*total_remaining_blocks != 0) { + /*triple indirect grand parent block connecting to inode */ + TI_gp_blockno = get_new_blk_no(); + if (TI_gp_blockno == -1) { + printf("no block left to assign\n"); + goto fail; + } + TI_gp_buff = xzalloc(fs->blksz); + if (!TI_gp_buff) + goto fail; + + TI_gp_buff_start_addr = TI_gp_buff; + (*no_blks_reqd)++; + debug("TIGPB %ld: %u\n", TI_gp_blockno, + *total_remaining_blocks); + + /* for each 4 byte grand parent entry create one more block */ + for (i = 0; i < (fs->blksz / sizeof(int)); i++) { + TI_parent_blockno = get_new_blk_no(); + if (TI_parent_blockno == -1) { + printf("no block left to assign\n"); + goto fail; + } + TI_parent_buff = xzalloc(fs->blksz); + if (!TI_parent_buff) + goto fail; + + TI_pbuff_start_addr = TI_parent_buff; + *TI_gp_buff = TI_parent_blockno; + TI_gp_buff++; + (*no_blks_reqd)++; + debug("TIPB %ld: %u\n", TI_parent_blockno, + *total_remaining_blocks); + + /*for each 4 byte entry parent create one more block */ + for (j = 0; j < (fs->blksz / sizeof(int)); j++) { + TI_child_blockno = get_new_blk_no(); + if (TI_child_blockno == -1) { + printf("no block" + "left assign\n"); + goto fail; + } + TI_child_buff = xzalloc(fs->blksz); + if (!TI_child_buff) + goto fail; + + TI_cbuff_start_addr = TI_child_buff; + *TI_parent_buff = TI_child_blockno; + TI_parent_buff++; + (*no_blks_reqd)++; + debug("TICB %ld: %u\n", TI_parent_blockno, + *total_remaining_blocks); + + /*filling of actual datablocks for each child */ + for (k = 0; k < (fs->blksz / sizeof(int)); + k++) { + actual_block_no = get_new_blk_no(); + if (actual_block_no == -1) { + printf("no block" + "left to assign\n"); + goto fail; + } + *TI_child_buff = actual_block_no; + debug("TIAB %ld: %u\n", actual_block_no, + *total_remaining_blocks); + + TI_child_buff++; + (*total_remaining_blocks)--; + if (*total_remaining_blocks == 0) + break; + } + /*write the child block */ + put_ext4(((uint64_t) (TI_child_blockno * + fs->blksz)), + TI_cbuff_start_addr, fs->blksz); + if (TI_cbuff_start_addr) + free(TI_cbuff_start_addr); + + if (*total_remaining_blocks == 0) + break; + } + /*write the parent block */ + put_ext4(((uint64_t) (TI_parent_blockno * fs->blksz)), + TI_pbuff_start_addr, fs->blksz); + if (TI_pbuff_start_addr) + free(TI_pbuff_start_addr); + + if (*total_remaining_blocks == 0) + break; + } + /*write the grand parent block */ + put_ext4(((uint64_t) (TI_gp_blockno * fs->blksz)), + TI_gp_buff_start_addr, fs->blksz); + file_inode->b.blocks.tripple_indir_block = TI_gp_blockno; + } +fail: + if (TI_gp_buff_start_addr) + free(TI_gp_buff_start_addr); + return; +} + +void allocate_blocks(struct ext2_inode *file_inode, + unsigned int total_remaining_blocks, + unsigned int *total_no_of_block) +{ + short i; + long int direct_blockno; + unsigned int no_blks_reqd = 0; + + /*-------------START:Allocation of Blocks to Inode-------------*/ + /*allocation of direct blocks */ + for (i = 0; i < INDIRECT_BLOCKS; i++) { + direct_blockno = get_new_blk_no(); + if (direct_blockno == -1) { + printf("no block left to assign\n"); + return; + } + file_inode->b.blocks.dir_blocks[i] = direct_blockno; + debug("DB %ld: %u\n", direct_blockno, total_remaining_blocks); + + total_remaining_blocks--; + if (total_remaining_blocks == 0) + break; + } + + /*allocation of single indirect blocks */ + alloc_single_indirect_block(file_inode, &total_remaining_blocks, + &no_blks_reqd); + + /*allocation of double indirect blocks */ + alloc_double_indirect_block(file_inode, &total_remaining_blocks, + &no_blks_reqd); + + /*allocation of triple indirect blocks */ + alloc_triple_indirect_block(file_inode, &total_remaining_blocks, + &no_blks_reqd); + + /*-----------------END:Allocation of Blocks to Inode-------------- */ + *total_no_of_block += no_blks_reqd; + return; +} + long int read_allocated_block(struct ext2_inode *inode, int fileblock) { long int blknr; diff --git a/fs/ext4/ext4_common.h b/fs/ext4/ext4_common.h index 73f218d..a2a7e7a 100644 --- a/fs/ext4/ext4_common.h +++ b/fs/ext4/ext4_common.h @@ -41,4 +41,21 @@ extern unsigned long part_offset; int ext4fs_read_inode(struct ext2_data *data, int ino, struct ext2_inode *inode); +uint32_t ext4fs_div_roundup(uint32_t size, uint32_t n); +int ext4fs_checksum_update(unsigned int i); +int get_parent_inode_num(char *dirname, char *dname, int flags); +void update_parent_dentry(char *filename, int *p_ino, int file_type); +long int get_new_blk_no(void); +int get_new_inode_no(void); +void reset_block_bmap(long int blockno, unsigned char *buffer, int index); +int set_block_bmap(long int blockno, unsigned char *buffer, int index); +int set_inode_bmap(int inode_no, unsigned char *buffer, int index); +void reset_inode_bmap(int inode_no, unsigned char *buffer, int index); +int iget(int inode_no, struct ext2_inode *inode); +void allocate_blocks(struct ext2_inode *file_inode, + unsigned int total_remaining_blocks, + unsigned int *total_no_of_block); +void put_ext4(uint64_t off, void *buf, uint32_t size); +unsigned int be_le(unsigned int num); +unsigned int le_be(unsigned int num); #endif diff --git a/fs/ext4/ext4_journal.c b/fs/ext4/ext4_journal.c new file mode 100644 index 0000000..fa9c89d --- /dev/null +++ b/fs/ext4/ext4_journal.c @@ -0,0 +1,650 @@ +/* + * (C) Copyright 2011 Samsung Electronics + * EXT4 filesystem implementation in Uboot by + * Uma Shankar <uma.shankar(a)samsung.com> + * Manjunatha C Achar <a.manjunatha(a)samsung.com> + * + * Copyright (C) 2003, 2004 Free Software Foundation, Inc. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * Journaling feature of ext4 has been referred from JBD2 + * (Journaling Block device 2) implementation in Linux Kernel + */ +#include <common.h> +#include "ext4_journal.h" +#include <ext_common.h> +#include <ext4fs.h> +#include <malloc.h> + +static struct revoke_blk_list *revk_blk_list; +static struct revoke_blk_list *prev_node; +static int first_node = TRUE; + +int gindex; +int gd_index; +int jrnl_blk_idx; +struct journal_log *journal_ptr[MAX_JOURNAL_ENTRIES]; +struct dirty_blocks *dirty_block_ptr[MAX_JOURNAL_ENTRIES]; + +int init_journal(void) +{ + int i; + char *temp = NULL; + struct ext_filesystem *fs = get_fs(); + + /*init globals */ + revk_blk_list = NULL; + prev_node = NULL; + gindex = 0; + gd_index = 0; + jrnl_blk_idx = 1; + + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + journal_ptr[i] = (struct journal_log *)xzalloc + (sizeof(struct journal_log)); + if (!journal_ptr[i]) + goto fail; + dirty_block_ptr[i] = (struct dirty_blocks *) + xzalloc(sizeof(struct dirty_blocks)); + if (!dirty_block_ptr[i]) + goto fail; + journal_ptr[i]->buf = NULL; + journal_ptr[i]->blknr = -1; + + dirty_block_ptr[i]->buf = NULL; + dirty_block_ptr[i]->blknr = -1; + } + + if (fs->blksz == 4096) { + temp = (char *)xzalloc(fs->blksz); + if (!temp) + goto fail; + journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz); + if (!journal_ptr[gindex]->buf) + goto fail; + ext2fs_devread(0, 0, fs->blksz, temp); + memcpy(temp + SUPERBLOCK_SIZE, fs->sb, SUPERBLOCK_SIZE); + memcpy(journal_ptr[gindex]->buf, temp, fs->blksz); + journal_ptr[gindex++]->blknr = 0; + free(temp); + } else { + journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz); + if (!journal_ptr[gindex]->buf) + goto fail; + memcpy(journal_ptr[gindex]->buf, fs->sb, SUPERBLOCK_SIZE); + journal_ptr[gindex++]->blknr = 1; + } + + /* Check the file system state using journal super block */ + if (check_journal_state(SCAN)) + goto fail; + if (check_journal_state(RECOVER)) + goto fail; + return 0; +fail: + return -1; +} + +void dump_metadata(void) +{ + struct ext_filesystem *fs = get_fs(); + int i; + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + if (dirty_block_ptr[i]->blknr == -1) + break; + put_ext4((uint64_t) (dirty_block_ptr[i]->blknr * fs->blksz), + dirty_block_ptr[i]->buf, (uint32_t) fs->blksz); + } + return; +} + +void free_journal(void) +{ + int i; + jrnl_blk_idx = 1; + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + if (dirty_block_ptr[i]->blknr == -1) + break; + if (dirty_block_ptr[i]->buf) + free(dirty_block_ptr[i]->buf); + } + + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + if (journal_ptr[i]->blknr == -1) + break; + if (journal_ptr[i]->buf) + free(journal_ptr[i]->buf); + } + + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + if (journal_ptr[i]) + free(journal_ptr[i]); + if (dirty_block_ptr[i]) + free(dirty_block_ptr[i]); + } + gindex = 0; + gd_index = 0; + return; +} + +int log_gdt(char *gd_table) +{ + struct ext_filesystem *fs = get_fs(); + short i; + long int var = fs->gdtable_blkno; + for (i = 0; i < fs->no_blk_pergdt; i++) { + journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz); + if (!journal_ptr[gindex]->buf) + return -1; + memcpy(journal_ptr[gindex]->buf, gd_table, fs->blksz); + gd_table += fs->blksz; + journal_ptr[gindex++]->blknr = var++; + } + return 0; +} + +/* This function stores the backup copy of meta data in RAM +* journal_buffer -- Buffer containing meta data +* blknr -- Block number on disk of the meta data buffer +*/ +int log_journal(char *journal_buffer, long int blknr) +{ + struct ext_filesystem *fs = get_fs(); + short i; + + if (!journal_buffer) { + printf("Invalid input arguments %s\n", __func__); + return -1; + } + + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + if (journal_ptr[i]->blknr == -1) + break; + if (journal_ptr[i]->blknr == blknr) + return 0; + } + + journal_ptr[gindex]->buf = (char *)xzalloc(fs->blksz); + if (!journal_ptr[gindex]->buf) + return -1; + + memcpy(journal_ptr[gindex]->buf, journal_buffer, fs->blksz); + journal_ptr[gindex++]->blknr = blknr; + return 0; +} + +/* This function stores the modified meta data in RAM +* metadata_buffer -- Buffer containing meta data +* blknr -- Block number on disk of the meta data buffer +*/ +int put_metadata(char *metadata_buffer, long int blknr) +{ + struct ext_filesystem *fs = get_fs(); + if (!metadata_buffer) { + printf("Invalid input arguments %s\n", __func__); + return -1; + } + dirty_block_ptr[gd_index]->buf = (char *)xzalloc(fs->blksz); + if (!dirty_block_ptr[gd_index]->buf) + return -1; + memcpy(dirty_block_ptr[gd_index]->buf, metadata_buffer, fs->blksz); + dirty_block_ptr[gd_index++]->blknr = blknr; + return 0; +} + +/*------------------------------------*/ +/*Revoke block handling functions*/ +void print_revoke_blks(char *revk_blk) +{ + struct journal_revoke_header_t *header; + int offset, max; + long int blocknr; + + if (revk_blk == NULL) + return; + + header = (struct journal_revoke_header_t *) revk_blk; + offset = sizeof(struct journal_revoke_header_t); + max = be_le(header->r_count); + printf("total bytes %d\n", max); + + while (offset < max) { + blocknr = be_le(*((long int *)(revk_blk + offset))); + printf("revoke blknr is %ld\n", blocknr); + offset += 4; + } + return; +} + +static struct revoke_blk_list *_get_node(void) +{ + struct revoke_blk_list *tmp_node; + tmp_node = (struct revoke_blk_list *) + malloc(sizeof(struct revoke_blk_list)); + if (tmp_node == NULL) + return NULL; + tmp_node->content = NULL; + tmp_node->next = NULL; + return tmp_node; +} + +void push_revoke_blk(char *buffer) +{ + struct revoke_blk_list *node; + struct ext_filesystem *fs = get_fs(); + if (buffer == NULL) { + printf("buffer ptr is NULL\n"); + return; + } + node = _get_node(); + if (!node) { + printf("_get_node: malloc failed\n"); + return; + } + + node->content = (char *)malloc(fs->blksz); + memcpy(node->content, buffer, fs->blksz); + + if (first_node == TRUE) { + revk_blk_list = node; + prev_node = node; + first_node = FALSE; + } else { + prev_node->next = node; + prev_node = node; + } + return; +} + +void free_revoke_blks() +{ + struct revoke_blk_list *tmp_node = revk_blk_list; + struct revoke_blk_list *next_node = NULL; + + while (tmp_node != NULL) { + if (tmp_node->content) + free(tmp_node->content); + tmp_node = tmp_node->next; + } + + tmp_node = revk_blk_list; + while (tmp_node != NULL) { + next_node = tmp_node->next; + free(tmp_node); + tmp_node = next_node; + } + + revk_blk_list = NULL; + prev_node = NULL; + first_node = TRUE; + return; +} + +int check_blknr_for_revoke(long int blknr, int sequence_no) +{ + struct journal_revoke_header_t *header; + int offset, max; + long int blocknr; + char *revk_blk; + struct revoke_blk_list *tmp_revk_node = revk_blk_list; + while (tmp_revk_node != NULL) { + revk_blk = tmp_revk_node->content; + + header = (struct journal_revoke_header_t *) revk_blk; + if (sequence_no <= be_le(header->r_header.h_sequence)) { + offset = sizeof(struct journal_revoke_header_t); + max = be_le(header->r_count); + + while (offset < max) { + blocknr = be_le(*((long int *) + (revk_blk + offset))); + if (blocknr == blknr) + goto found; + offset += 4; + } + } + tmp_revk_node = tmp_revk_node->next; + } + return -1; + +found: + return 0; +} + +/* +* This function parses the journal blocks and replays the +* suceessful transactions. A transaction is successfull +* if commit block is found for a descriptor block +* The tags in descriptor block contain the disk block +* numbers of the metadata to be replayed +*/ +void recover_transaction(int prev_desc_logical_no) +{ + struct ext2_inode inode_journal; + struct ext_filesystem *fs = get_fs(); + struct journal_header_t *jdb; + long int blknr; + char *p_jdb; + int ofs, flags; + int i; + struct ext3_journal_block_tag *tag; + char *temp_buff = (char *)xzalloc(fs->blksz); + char *metadata_buff = (char *)xzalloc(fs->blksz); + if (!temp_buff || !metadata_buff) + goto fail; + i = prev_desc_logical_no; + ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, + (struct ext2_inode *)&inode_journal); + blknr = read_allocated_block((struct ext2_inode *) + &inode_journal, i); + ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, temp_buff); + p_jdb = (char *)temp_buff; + jdb = (struct journal_header_t *) temp_buff; + ofs = sizeof(struct journal_header_t); + + do { + tag = (struct ext3_journal_block_tag *)&p_jdb[ofs]; + ofs += sizeof(struct ext3_journal_block_tag); + + if (ofs > fs->blksz) + break; + + flags = be_le(tag->flags); + if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) + ofs += 16; + + i++; + debug("\t\ttag %u\n", be_le(tag->block)); + if (revk_blk_list != NULL) { + if (check_blknr_for_revoke(be_le(tag->block), + be_le(jdb->h_sequence)) == + 0) { + continue; + } + } + blknr = read_allocated_block(&inode_journal, i); + ext2fs_devread(blknr * fs->sect_perblk, 0, + fs->blksz, metadata_buff); + put_ext4((uint64_t) (be_le(tag->block) * fs->blksz), + metadata_buff, (uint32_t) fs->blksz); + } while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG)); +fail: + if (temp_buff) + free(temp_buff); + if (metadata_buff) + free(metadata_buff); +} + +void print_jrnl_status(int recovery_flag) +{ + if (recovery_flag == RECOVER) + printf("Journal Recovery Completed\n"); + else + printf("Journal Scan Completed\n"); + return; +} + +int check_journal_state(int recovery_flag) +{ + struct ext2_inode inode_journal; + struct ext_filesystem *fs = get_fs(); + struct journal_superblock_t *jsb; + struct journal_header_t *jdb; + char *p_jdb; + int i; + int DB_FOUND = NO; + long int blknr; + int transaction_state = TRANSACTION_COMPLETE; + int prev_desc_logical_no = 0; + int curr_desc_logical_no = 0; + int ofs, flags, block; + struct ext3_journal_block_tag *tag; + char *temp_buff, *temp_buff1; + + temp_buff = (char *)xzalloc(fs->blksz); + if (!temp_buff) + return -1; + temp_buff1 = (char *)xzalloc(fs->blksz); + if (!temp_buff1) { + free(temp_buff); + return -1; + } + + ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal); + blknr = read_allocated_block(&inode_journal, EXT2_JOURNAL_SUPERBLOCK); + ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, temp_buff); + jsb = (struct journal_superblock_t *) temp_buff; + + if (fs->sb->feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER) { + if (recovery_flag == RECOVER) + printf("Recovery required\n"); + } else { + if (recovery_flag == RECOVER) + printf("File System is consistent\n"); + goto END; + } + + if (be_le(jsb->s_start) == 0) + goto END; + + if (!(jsb->s_feature_compat & le_be(JBD2_FEATURE_COMPAT_CHECKSUM))) + jsb->s_feature_compat |= le_be(JBD2_FEATURE_COMPAT_CHECKSUM); + + i = be_le(jsb->s_first); + while (1) { + block = be_le(jsb->s_first); + blknr = read_allocated_block(&inode_journal, i); + memset(temp_buff1, '\0', fs->blksz); + ext2fs_devread(blknr * fs->sect_perblk, + 0, fs->blksz, temp_buff1); + jdb = (struct journal_header_t *) temp_buff1; + + if (be_le(jdb->h_blocktype) == EXT3_JOURNAL_DESCRIPTOR_BLOCK) { + if (be_le(jdb->h_sequence) != be_le(jsb->s_sequence)) { + print_jrnl_status(recovery_flag); + break; + } + + curr_desc_logical_no = i; + if (transaction_state == TRANSACTION_COMPLETE) + transaction_state = TRANSACTION_RUNNING; + else + return -1; + p_jdb = (char *)temp_buff1; + ofs = sizeof(struct journal_header_t); + do { + tag = (struct ext3_journal_block_tag *) + &p_jdb[ofs]; + ofs += sizeof(struct ext3_journal_block_tag); + if (ofs > fs->blksz) + break; + flags = be_le(tag->flags); + if (!(flags & EXT3_JOURNAL_FLAG_SAME_UUID)) + ofs += 16; + i++; + debug("\t\ttag %u\n", be_le(tag->block)); + } while (!(flags & EXT3_JOURNAL_FLAG_LAST_TAG)); + i++; + DB_FOUND = YES; + } else if (be_le(jdb->h_blocktype) == + EXT3_JOURNAL_COMMIT_BLOCK) { + if ((be_le(jdb->h_sequence) != be_le(jsb->s_sequence)) + || (DB_FOUND == NO)) { + print_jrnl_status(recovery_flag); + break; + } + + if (transaction_state == TRANSACTION_RUNNING) { + transaction_state = TRANSACTION_COMPLETE; + i++; + jsb->s_sequence = + le_be(be_le(jsb->s_sequence) + 1); + } + prev_desc_logical_no = curr_desc_logical_no; + recover_transaction(prev_desc_logical_no); + DB_FOUND = NO; + } else if (be_le(jdb->h_blocktype) == + EXT3_JOURNAL_REVOKE_BLOCK) { + if (be_le(jdb->h_sequence) != be_le(jsb->s_sequence)) { + print_jrnl_status(recovery_flag); + break; + } + if (recovery_flag == SCAN) + push_revoke_blk((char *)jdb); + i++; + } else { + debug("Else Case\n"); + if (be_le(jdb->h_sequence) != be_le(jsb->s_sequence)) { + print_jrnl_status(recovery_flag); + break; + } + } + } + +END: + if (recovery_flag == RECOVER) { + jsb->s_start = le_be(1); + jsb->s_sequence = le_be(be_le(jsb->s_sequence) + 1); + ext2fs_devread(SUPERBLOCK_SECTOR, 0, SUPERBLOCK_SIZE, + (char *)fs->sb); + fs->sb->feature_incompat |= EXT3_FEATURE_INCOMPAT_RECOVER; + + put_ext4((uint64_t) (SUPERBLOCK_SIZE), + (struct ext2_sblock *)fs->sb, + (uint32_t) SUPERBLOCK_SIZE); + ext2fs_devread(SUPERBLOCK_SECTOR, 0, SUPERBLOCK_SIZE, + (char *)fs->sb); + + blknr = + read_allocated_block(&inode_journal, + EXT2_JOURNAL_SUPERBLOCK); + put_ext4((uint64_t) (blknr * fs->blksz), + (struct journal_superblock_t *)temp_buff, + (uint32_t) fs->blksz); + free_revoke_blks(); + } + free(temp_buff); + free(temp_buff1); + + return 0; +} + +static void update_descriptor_block(long int blknr) +{ + struct journal_header_t jdb; + struct ext3_journal_block_tag tag; + struct ext2_inode inode_journal; + struct journal_superblock_t *jsb; + long int jsb_blknr; + struct ext_filesystem *fs = get_fs(); + char *buf = NULL, *temp = NULL; + int i; + char *temp_buff = (char *)xzalloc(fs->blksz); + if (!temp_buff) + return; + + ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal); + jsb_blknr = read_allocated_block(&inode_journal, + EXT2_JOURNAL_SUPERBLOCK); + ext2fs_devread(jsb_blknr * fs->sect_perblk, 0, fs->blksz, temp_buff); + jsb = (struct journal_superblock_t *) temp_buff; + + jdb.h_blocktype = le_be(EXT3_JOURNAL_DESCRIPTOR_BLOCK); + jdb.h_magic = le_be(EXT3_JOURNAL_MAGIC_NUMBER); + jdb.h_sequence = jsb->s_sequence; + buf = (char *)xzalloc(fs->blksz); + if (!buf) { + free(temp_buff); + return; + } + temp = buf; + memcpy(buf, &jdb, sizeof(struct journal_header_t)); + temp += sizeof(struct journal_header_t); + + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + if (journal_ptr[i]->blknr == -1) + break; + + tag.block = le_be(journal_ptr[i]->blknr); + tag.flags = le_be(EXT3_JOURNAL_FLAG_SAME_UUID); + memcpy(temp, &tag, sizeof(struct ext3_journal_block_tag)); + temp = temp + sizeof(struct ext3_journal_block_tag); + } + + tag.block = le_be(journal_ptr[--i]->blknr); + tag.flags = le_be(EXT3_JOURNAL_FLAG_LAST_TAG); + memcpy(temp - sizeof(struct ext3_journal_block_tag), &tag, + sizeof(struct ext3_journal_block_tag)); + put_ext4((uint64_t) (blknr * fs->blksz), buf, (uint32_t) fs->blksz); + + free(temp_buff); + free(buf); +} + +static void update_commit_block(long int blknr) +{ + struct journal_header_t jdb; + struct ext_filesystem *fs = get_fs(); + char *buf = NULL; + struct ext2_inode inode_journal; + struct journal_superblock_t *jsb; + long int jsb_blknr; + char *temp_buff = (char *)xzalloc(fs->blksz); + if (!temp_buff) + return; + + ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal); + jsb_blknr = read_allocated_block(&inode_journal, + EXT2_JOURNAL_SUPERBLOCK); + ext2fs_devread(jsb_blknr * fs->sect_perblk, 0, fs->blksz, temp_buff); + jsb = (struct journal_superblock_t *) temp_buff; + + jdb.h_blocktype = le_be(EXT3_JOURNAL_COMMIT_BLOCK); + jdb.h_magic = le_be(EXT3_JOURNAL_MAGIC_NUMBER); + jdb.h_sequence = jsb->s_sequence; + buf = (char *)xzalloc(fs->blksz); + if (!buf) { + free(temp_buff); + return; + } + memcpy(buf, &jdb, sizeof(struct journal_header_t)); + put_ext4((uint64_t) (blknr * fs->blksz), buf, (uint32_t) fs->blksz); + + free(temp_buff); + free(buf); +} + +void update_journal(void) +{ + struct ext2_inode inode_journal; + struct ext_filesystem *fs = get_fs(); + long int blknr; + int i; + ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, &inode_journal); + blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++); + update_descriptor_block(blknr); + for (i = 0; i < MAX_JOURNAL_ENTRIES; i++) { + if (journal_ptr[i]->blknr == -1) + break; + blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++); + put_ext4((uint64_t) (blknr * fs->blksz), + journal_ptr[i]->buf, (uint32_t) fs->blksz); + } + blknr = read_allocated_block(&inode_journal, jrnl_blk_idx++); + update_commit_block(blknr); + printf("update journal finished\n"); +} diff --git a/fs/ext4/ext4_journal.h b/fs/ext4/ext4_journal.h new file mode 100644 index 0000000..e4413d2 --- /dev/null +++ b/fs/ext4/ext4_journal.h @@ -0,0 +1,147 @@ +/* + * (C) Copyright 2011 Samsung Electronics + * EXT4 filesystem implementation in Uboot by + * Uma Shankar <uma.shankar(a)samsung.com> + * Manjunatha C Achar <a.manjunatha(a)samsung.com> + * + * Copyright (C) 2003, 2004 Free Software Foundation, Inc. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +/* + * Journaling feature of ext4 has been referred from JBD2 + * (Journaling Block device 2) implementation in Linux Kernel + */ + +#ifndef __EXT4_JRNL__ +#define __EXT4_JRNL__ + +#include "ext4_common.h" + +#define EXT2_JOURNAL_INO 8 /* Journal inode */ +#define EXT2_JOURNAL_SUPERBLOCK 0 /* Journal Superblock number */ + +#define JBD2_FEATURE_COMPAT_CHECKSUM 0x00000001 +#define EXT3_JOURNAL_MAGIC_NUMBER 0xc03b3998U +#define TRANSACTION_RUNNING 1 +#define TRANSACTION_COMPLETE 0 +#define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */ +#define EXT3_JOURNAL_DESCRIPTOR_BLOCK 1 +#define EXT3_JOURNAL_COMMIT_BLOCK 2 +#define EXT3_JOURNAL_SUPERBLOCK_V1 3 +#define EXT3_JOURNAL_SUPERBLOCK_V2 4 +#define EXT3_JOURNAL_REVOKE_BLOCK 5 +#define EXT3_JOURNAL_FLAG_ESCAPE 1 +#define EXT3_JOURNAL_FLAG_SAME_UUID 2 +#define EXT3_JOURNAL_FLAG_DELETED 4 +#define EXT3_JOURNAL_FLAG_LAST_TAG 8 + +/* Maximum entries in 1 journal transaction */ +#define MAX_JOURNAL_ENTRIES 100 +struct journal_log { + char *buf; + int blknr; +}; + +struct dirty_blocks { + char *buf; + int blknr; +}; + +/* + * Standard header for all descriptor blocks: + */ +struct journal_header_t { + __u32 h_magic; + __u32 h_blocktype; + __u32 h_sequence; +}; + +/* + * The journal superblock. All fields are in big-endian byte order. + */ +struct journal_superblock_t { + /* 0x0000 */ + struct journal_header_t s_header; + + /* 0x000C */ + /* Static information describing the journal */ + __u32 s_blocksize; /* journal device blocksize */ + __u32 s_maxlen; /* total blocks in journal file */ + __u32 s_first; /* first block of log information */ + + /* 0x0018 */ + /* Dynamic information describing the current state of the log */ + __u32 s_sequence; /* first commit ID expected in log */ + __u32 s_start; /* blocknr of start of log */ + + /* 0x0020 */ + /* Error value, as set by journal_abort(). */ + __s32 s_errno; + + /* 0x0024 */ + /* Remaining fields are only valid in a version-2 superblock */ + __u32 s_feature_compat; /* compatible feature set */ + __u32 s_feature_incompat; /* incompatible feature set */ + __u32 s_feature_ro_compat; /* readonly-compatible feature set */ + /* 0x0030 */ + __u8 s_uuid[16]; /* 128-bit uuid for journal */ + + /* 0x0040 */ + __u32 s_nr_users; /* Nr of filesystems sharing log */ + + __u32 s_dynsuper; /* Blocknr of dynamic superblock copy */ + + /* 0x0048 */ + __u32 s_max_transaction; /* Limit of journal blocks per trans. */ + __u32 s_max_trans_data; /* Limit of data blocks per trans. */ + + /* 0x0050 */ + __u32 s_padding[44]; + + /* 0x0100 */ + __u8 s_users[16 * 48]; /* ids of all fs'es sharing the log */ + /* 0x0400 */ +} ; + +struct ext3_journal_block_tag { + uint32_t block; + uint32_t flags; +}; + +struct journal_revoke_header_t { + struct journal_header_t r_header; + int r_count; /* Count of bytes used in the block */ +}; + +struct revoke_blk_list { + char *content; /*revoke block itself */ + struct revoke_blk_list *next; +}; + +extern struct ext2_data *ext4fs_root; + +int init_journal(void); +void deinit_journal(void); +int log_gdt(char *gd_table); +void update_journal(void); +int check_journal_state(int recovery_flag); +int log_journal(char *journal_buffer, long int blknr); +int put_metadata(char *metadata_buffer, long int blknr); +void dump_metadata(void); +void free_journal(void); +void free_revoke_blks(void); +void push_revoke_blk(char *buffer); +#endif diff --git a/fs/ext4/ext4fs.c b/fs/ext4/ext4fs.c index d4faa16..0a033aa 100644 --- a/fs/ext4/ext4fs.c +++ b/fs/ext4/ext4fs.c @@ -22,7 +22,13 @@ /* * ext4load - based on code from GRUB2 fs/ext2.c -*/ + * + * ext4write - based on existing ext2 support in UBOOT and ext4 + * implementation in Linux Kernel. + * Journaling feature of ext4 has been referred from JBD2 + * (Journaling Block device 2) implementation in Linux Kernel + */ + #include <common.h> #include <malloc.h> #include <asm/byteorder.h> @@ -31,6 +37,7 @@ #include <ext_common.h> #include <ext4fs.h> #include "ext4_common.h" +#include "ext4_journal.h" int ext4fs_symlinknest; block_dev_desc_t *ext4_dev_desc; @@ -213,3 +220,1032 @@ int ext4fs_read(char *buf, unsigned len) return 0; return ext4fs_read_file(ext4fs_file, 0, len, buf); } + +static void ext4fs_update(void) +{ + short i; + update_journal(); + struct ext_filesystem *fs = get_fs(); + + /*Update the super block */ + put_ext4((uint64_t) (SUPERBLOCK_SIZE), + (struct ext2_sblock *)fs->sb, (uint32_t) SUPERBLOCK_SIZE); + + /*update the block group */ + for (i = 0; i < fs->no_blkgrp; i++) { + fs->gd[i].bg_checksum = ext4fs_checksum_update(i); + put_ext4((uint64_t) (fs->gd[i].block_id * fs->blksz), + fs->blk_bmaps[i], (uint32_t) fs->blksz); + } + + /*update the inode table group */ + for (i = 0; i < fs->no_blkgrp; i++) { + put_ext4((uint64_t) (fs->gd[i].inode_id * fs->blksz), + fs->inode_bmaps[i], (uint32_t) fs->blksz); + } + + /*update the block group descriptor table */ + put_ext4((uint64_t) (fs->gdtable_blkno * fs->blksz), + (struct ext2_block_group *)fs->gdtable, (uint32_t) + (fs->blksz * fs->no_blk_pergdt)); + + dump_metadata(); + + gindex = 0; + gd_index = 0; +} + +int ext4fs_get_bgdtable(void) +{ + int status; + int grp_desc_size; + struct ext_filesystem *fs = get_fs(); + grp_desc_size = sizeof(struct ext2_block_group); + fs->no_blk_pergdt = (fs->no_blkgrp * grp_desc_size) / fs->blksz; + if ((fs->no_blkgrp * grp_desc_size) % fs->blksz) + fs->no_blk_pergdt++; + + /*allocate mem for gdtable */ + fs->gdtable = (char *)xzalloc(fs->blksz * fs->no_blk_pergdt); + if (!fs->gdtable) + return -1; + /*Read the first group descriptor table */ + status = ext2fs_devread(fs->gdtable_blkno * fs->sect_perblk, 0, + fs->blksz * fs->no_blk_pergdt, fs->gdtable); + if (status == 0) + goto fail; + + if (log_gdt(fs->gdtable)) { + printf("Error in log_gdt\n"); + return -1; + } + + return 0; +fail: + if (fs->gdtable) { + free(fs->gdtable); + fs->gdtable = NULL; + } + return -1; +} + +static void delete_single_indirect_block(struct ext2_inode *inode) +{ + struct ext2_block_group *gd; + static int prev_bg_bitmap_index = -1; + long int blknr; + int remainder; + int bg_idx; + int status; + struct ext_filesystem *fs = get_fs(); + char *journal_buffer = (char *)xzalloc(fs->blksz); + if (!journal_buffer) + return; + /*get the block group descriptor table */ + gd = (struct ext2_block_group *)fs->gdtable; + + /*deleting the single indirect block associated with inode */ + if (inode->b.blocks.indir_block != 0) { + debug("SIPB releasing %u\n", inode->b.blocks.indir_block); + blknr = inode->b.blocks.indir_block; + if (fs->blksz != 1024) { + bg_idx = blknr / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + } else { + bg_idx = blknr / + (uint32_t) ext4fs_root->sblock.blocks_per_group; + remainder = blknr % (uint32_t) + ext4fs_root->sblock.blocks_per_group; + if (!remainder) + bg_idx--; + } + reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + status = + ext2fs_devread(gd[bg_idx].block_id * + fs->sect_perblk, 0, fs->blksz, + journal_buffer); + if (status == 0) + goto fail; + if (log_journal(journal_buffer, gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + } +fail: + if (journal_buffer) + free(journal_buffer); + return; + +} + +/*deleting the double indirect blocks */ +static void delete_double_indirect_block(struct ext2_inode *inode) +{ + int i; + short status; + static int prev_bg_bitmap_index = -1; + long int blknr; + int remainder; + int bg_idx; + unsigned int *double_indirect_buffer; + unsigned int *DIB_start_addr = NULL; + struct ext2_block_group *gd; + struct ext_filesystem *fs = get_fs(); + char *journal_buffer = (char *)xzalloc(fs->blksz); + if (!journal_buffer) + return; + /*get the block group descriptor table */ + gd = (struct ext2_block_group *)fs->gdtable; + + if (inode->b.blocks.double_indir_block != 0) { + double_indirect_buffer = (unsigned int *)xzalloc(fs->blksz); + if (!double_indirect_buffer) + return; + DIB_start_addr = (unsigned int *)double_indirect_buffer; + blknr = inode->b.blocks.double_indir_block; + status = ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, + (char *)double_indirect_buffer); + for (i = 0; i < fs->blksz / sizeof(int); i++) { + if (*double_indirect_buffer == 0) + break; + + debug("DICB releasing %u\n", *double_indirect_buffer); + if (fs->blksz != 1024) { + bg_idx = (*double_indirect_buffer) / + (uint32_t) ext4fs_root->sblock. + blocks_per_group; + } else { + bg_idx = (*double_indirect_buffer) / + (uint32_t) ext4fs_root->sblock. + blocks_per_group; + remainder = + (*double_indirect_buffer) % + (uint32_t) ext4fs_root->sblock. + blocks_per_group; + if (!remainder) + bg_idx--; + } + reset_block_bmap(*double_indirect_buffer, + fs->blk_bmaps[bg_idx], bg_idx); + double_indirect_buffer++; + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + status = ext2fs_devread(gd[bg_idx].block_id + * fs->sect_perblk, 0, + fs->blksz, + journal_buffer); + if (status == 0) + goto fail; + + if (log_journal(journal_buffer, + gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + } + + /*removing the parent double indirect block */ + /*find the bitmap index */ + blknr = inode->b.blocks.double_indir_block; + if (fs->blksz != 1024) { + bg_idx = blknr / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + } else { + bg_idx = blknr / + (uint32_t) ext4fs_root->sblock.blocks_per_group; + remainder = + blknr % + (uint32_t) ext4fs_root->sblock.blocks_per_group; + if (!remainder) + bg_idx--; + } + reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + memset(journal_buffer, '\0', fs->blksz); + status = ext2fs_devread(gd[bg_idx].block_id * + fs->sect_perblk, 0, fs->blksz, + journal_buffer); + if (status == 0) + goto fail; + + if (log_journal(journal_buffer, gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + debug("DIPB releasing %ld\n", blknr); + } +fail: + if (DIB_start_addr) + free(DIB_start_addr); + if (journal_buffer) + free(journal_buffer); + return; +} + +/*deleting the triple indirect blocks */ +static void delete_triple_indirect_block(struct ext2_inode *inode) +{ + int i, j; + short status; + static int prev_bg_bitmap_index = -1; + long int blknr; + int remainder; + int bg_idx; + unsigned int *TIGP_buffer = NULL; + unsigned int *TIB_start_addr = NULL; + unsigned int *TIP_buffer = NULL; + unsigned int *TIPB_start_addr = NULL; + struct ext2_block_group *gd; + struct ext_filesystem *fs = get_fs(); + char *journal_buffer = (char *)xzalloc(fs->blksz); + if (!journal_buffer) + return; + /*get the block group descriptor table */ + gd = (struct ext2_block_group *)fs->gdtable; + + if (inode->b.blocks.tripple_indir_block != 0) { + TIGP_buffer = (unsigned int *)xzalloc(fs->blksz); + if (!TIGP_buffer) + return; + TIB_start_addr = (unsigned int *)TIGP_buffer; + blknr = inode->b.blocks.tripple_indir_block; + status = ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, + (char *)TIGP_buffer); + for (i = 0; i < fs->blksz / sizeof(int); i++) { + if (*TIGP_buffer == 0) + break; + debug("TIGPB releasing %u\n", *TIGP_buffer); + + TIP_buffer = (unsigned int *)xzalloc(fs->blksz); + if (!TIP_buffer) + goto fail; + TIPB_start_addr = (unsigned int *)TIP_buffer; + status = ext2fs_devread((*TIGP_buffer) * + fs->sect_perblk, 0, fs->blksz, + (char *)TIP_buffer); + for (j = 0; j < fs->blksz / sizeof(int); j++) { + if (*TIP_buffer == 0) + break; + if (fs->blksz != 1024) { + bg_idx = (*TIP_buffer) / (uint32_t) + ext4fs_root->sblock. + blocks_per_group; + } else { + bg_idx = (*TIP_buffer) / (uint32_t) + ext4fs_root->sblock. + blocks_per_group; + + remainder = (*TIP_buffer) % (uint32_t) + ext4fs_root->sblock. + blocks_per_group; + if (!remainder) + bg_idx--; + } + + reset_block_bmap(*TIP_buffer, + fs->blk_bmaps[bg_idx], bg_idx); + + TIP_buffer++; + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + status = + ext2fs_devread(gd[bg_idx].block_id * + fs->sect_perblk, 0, + fs->blksz, + journal_buffer); + if (status == 0) + goto fail; + + if (log_journal(journal_buffer, + gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + } + if (TIPB_start_addr) { + free(TIPB_start_addr); + TIPB_start_addr = NULL; + } + + /*removing the grand parent blocks + *which is connected to inode + */ + if (fs->blksz != 1024) { + bg_idx = (*TIGP_buffer) / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + } else { + bg_idx = (*TIGP_buffer) / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + + remainder = (*TIGP_buffer) % (uint32_t) + ext4fs_root->sblock.blocks_per_group; + if (!remainder) + bg_idx--; + } + reset_block_bmap(*TIGP_buffer, + fs->blk_bmaps[bg_idx], bg_idx); + + TIGP_buffer++; + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + memset(journal_buffer, '\0', fs->blksz); + status = + ext2fs_devread(gd[bg_idx].block_id * + fs->sect_perblk, 0, + fs->blksz, journal_buffer); + if (status == 0) + goto fail; + + if (log_journal(journal_buffer, + gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + } + + /*removing the grand parent triple indirect block */ + /*find the bitmap index */ + blknr = inode->b.blocks.tripple_indir_block; + if (fs->blksz != 1024) { + bg_idx = blknr / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + } else { + bg_idx = blknr / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + remainder = blknr % (uint32_t) + ext4fs_root->sblock.blocks_per_group; + if (!remainder) + bg_idx--; + } + reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + memset(journal_buffer, '\0', fs->blksz); + status = ext2fs_devread(gd[bg_idx].block_id + * fs->sect_perblk, 0, fs->blksz, + journal_buffer); + if (status == 0) + goto fail; + + if (log_journal(journal_buffer, gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + debug("TIGPB iteself releasing %ld\n", blknr); + } +fail: + if (TIB_start_addr) + free(TIB_start_addr); + if (TIPB_start_addr) + free(TIPB_start_addr); + if (journal_buffer) + free(journal_buffer); + return; +} + +static int ext4fs_delete_file(int inodeno) +{ + struct ext2_inode inode; + short status; + int i; + int remainder; + long int blknr; + int bg_idx; + int inode_bitmap_index; + char *read_buffer; + char *start_block_address = NULL; + unsigned int no_blocks; + + static int prev_bg_bitmap_index = -1; + unsigned int inodes_per_block; + long int blkno; + unsigned int blkoff; + struct ext2_inode *inode_buffer; + struct ext2_block_group *gd; + struct ext_filesystem *fs = get_fs(); + char *journal_buffer = (char *)xzalloc(fs->blksz); + if (!journal_buffer) + return -1; + /*get the block group descriptor table */ + gd = (struct ext2_block_group *)fs->gdtable; + status = ext4fs_read_inode(ext4fs_root, inodeno, &inode); + if (status == 0) + goto fail; + + /*read the block no allocated to a file */ + no_blocks = inode.size / fs->blksz; + if (inode.size % fs->blksz) + no_blocks++; + + if (le32_to_cpu(inode.flags) & EXT4_EXTENTS_FLAG) { + struct ext2fs_node *node_inode = + (struct ext2fs_node *) xzalloc(sizeof(struct ext2fs_node)); + if (!node_inode) + goto fail; + node_inode->data = ext4fs_root; + node_inode->ino = inodeno; + node_inode->inode_read = 0; + memcpy(&(node_inode->inode), &inode, sizeof(struct ext2_inode)); + + for (i = 0; i < no_blocks; i++) { + blknr = read_allocated_block(&(node_inode->inode), i); + if (fs->blksz != 1024) { + bg_idx = blknr / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + } else { + bg_idx = blknr / (uint32_t) + ext4fs_root->sblock.blocks_per_group; + remainder = blknr % (uint32_t) + ext4fs_root->sblock.blocks_per_group; + if (!remainder) + bg_idx--; + } + reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); + debug("EXT4_EXTENTS Block releasing %ld: %d\n", + blknr, bg_idx); + + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + status = + ext2fs_devread(gd[bg_idx].block_id * + fs->sect_perblk, 0, + fs->blksz, journal_buffer); + if (status == 0) + goto fail; + if (log_journal(journal_buffer, + gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + } + if (node_inode) { + free(node_inode); + node_inode = NULL; + } + } else { + /*deleting the single indirect block associated with inode */ + delete_single_indirect_block(&inode); + + /*deleting the double indirect blocks */ + delete_double_indirect_block(&inode); + + /*deleting the triple indirect blocks */ + delete_triple_indirect_block(&inode); + + /*read the block no allocated to a file */ + no_blocks = inode.size / fs->blksz; + if (inode.size % fs->blksz) + no_blocks++; + for (i = 0; i < no_blocks; i++) { + blknr = read_allocated_block(&inode, i); + if (fs->blksz != 1024) { + bg_idx = blknr / + (uint32_t) ext4fs_root->sblock. + blocks_per_group; + } else { + bg_idx = + blknr / + (uint32_t) ext4fs_root->sblock. + blocks_per_group; + remainder = blknr % (uint32_t) + ext4fs_root->sblock.blocks_per_group; + if (!remainder) + bg_idx--; + } + reset_block_bmap(blknr, fs->blk_bmaps[bg_idx], bg_idx); + debug("ActualB releasing %ld: %d\n", blknr, bg_idx); + + gd[bg_idx].free_blocks++; + fs->sb->free_blocks++; + /*journal backup */ + if (prev_bg_bitmap_index != bg_idx) { + memset(journal_buffer, '\0', fs->blksz); + status = ext2fs_devread(gd[bg_idx].block_id + * fs->sect_perblk, + 0, fs->blksz, + journal_buffer); + if (status == 0) { + free(journal_buffer); + goto fail; + } + if (log_journal(journal_buffer, + gd[bg_idx].block_id)) + goto fail; + prev_bg_bitmap_index = bg_idx; + } + } + } + + /*from the inode no to blockno */ + inodes_per_block = EXT2_BLOCK_SIZE(ext4fs_root) / fs->inodesz; + inode_bitmap_index = inodeno / + (uint32_t) ext4fs_root->sblock.inodes_per_group; + + /*get the block no */ + inodeno--; + blkno = __le32_to_cpu(gd[inode_bitmap_index].inode_table_id) + + (inodeno % __le32_to_cpu(ext4fs_root->sblock.inodes_per_group)) + / inodes_per_block; + + /*get the offset of the inode */ + blkoff = ((inodeno) % inodes_per_block) * fs->inodesz; + + /*read the block no containing the inode */ + read_buffer = (char *)xzalloc(fs->blksz); + if (!read_buffer) + goto fail; + start_block_address = read_buffer; + status = ext2fs_devread(blkno * fs->sect_perblk, + 0, fs->blksz, read_buffer); + if (status == 0) + goto fail; + + if (log_journal(read_buffer, blkno)) + goto fail; + + read_buffer = read_buffer + blkoff; + inode_buffer = (struct ext2_inode *)read_buffer; + memset(inode_buffer, '\0', sizeof(struct ext2_inode)); + + /*write the inode to original position in inode table */ + if (put_metadata(start_block_address, blkno)) + goto fail; + + /*update the respective inode bitmaps */ + inodeno++; + reset_inode_bmap(inodeno, fs->inode_bmaps + [inode_bitmap_index], inode_bitmap_index); + gd[inode_bitmap_index].free_inodes++; + fs->sb->free_inodes++; + /*journal backup */ + memset(journal_buffer, '\0', fs->blksz); + status = ext2fs_devread(gd[inode_bitmap_index].inode_id * + fs->sect_perblk, 0, fs->blksz, journal_buffer); + if (status == 0) + goto fail; + if (log_journal(journal_buffer, gd[inode_bitmap_index].inode_id)) + goto fail; + + ext4fs_update(); + ext4fs_deinit(); + + if (ext4fs_init() != 0) { + printf("error in File System init\n"); + goto fail; + } + + /*free */ + if (start_block_address) + free(start_block_address); + if (journal_buffer) + free(journal_buffer); + return 0; + +fail: + if (start_block_address) + free(start_block_address); + if (journal_buffer) + free(journal_buffer); + return -1; +} + +int ext4fs_init(void) +{ + short status; + int i; + int sector_per_block; + unsigned int real_free_blocks = 0; + struct ext_filesystem *fs = get_fs(); + + /*populate fs */ + fs->blksz = EXT2_BLOCK_SIZE(ext4fs_root); + fs->inodesz = INODE_SIZE_FILESYSTEM(ext4fs_root); + fs->sect_perblk = fs->blksz / SECTOR_SIZE; + + sector_per_block = fs->sect_perblk; + /*get the superblock */ + fs->sb = (struct ext2_sblock *)xzalloc(SUPERBLOCK_SIZE); + if (!fs->sb) + return -1; + status = ext2fs_devread(SUPERBLOCK_SECTOR, 0, + SUPERBLOCK_SIZE, (char *)fs->sb); + if (status == 0) + goto fail; + + /*init journal */ + if (init_journal()) + goto fail; + + /*get the no of blockgroups */ + + fs->no_blkgrp = (uint32_t) ext4fs_div_roundup + ((uint32_t) (ext4fs_root->sblock.total_blocks + - ext4fs_root->sblock.first_data_block), + (uint32_t) ext4fs_root->sblock.blocks_per_group); + + /*get the block group descriptor table */ + fs->gdtable_blkno = ((EXT2_MIN_BLOCK_SIZE == fs->blksz) + 1); + if (ext4fs_get_bgdtable() == -1) { + printf("*Eror in getting the block group descriptor table\n"); + goto fail; + } else { + fs->gd = (struct ext2_block_group *)fs->gdtable; + } + + /*load all the available bitmap block of the partition */ + fs->blk_bmaps = (unsigned char **)xzalloc + (fs->no_blkgrp * sizeof(unsigned char *)); + if (!fs->blk_bmaps) + goto fail; + for (i = 0; i < fs->no_blkgrp; i++) { + fs->blk_bmaps[i] = (unsigned char *)xzalloc(fs->blksz); + if (!fs->blk_bmaps[i]) + goto fail; + } + + for (i = 0; i < fs->no_blkgrp; i++) { + status = + ext2fs_devread(fs->gd[i].block_id * sector_per_block, 0, + fs->blksz, (char *)fs->blk_bmaps[i]); + if (status == 0) + goto fail; + } + + /*load all the available inode bitmap of the partition */ + fs->inode_bmaps = (unsigned char **)xzalloc + (fs->no_blkgrp * sizeof(unsigned char *)); + if (!fs->inode_bmaps) + goto fail; + for (i = 0; i < fs->no_blkgrp; i++) { + fs->inode_bmaps[i] = (unsigned char *)xzalloc(fs->blksz); + if (!fs->inode_bmaps[i]) + goto fail; + } + + for (i = 0; i < fs->no_blkgrp; i++) { + status = ext2fs_devread(fs->gd[i].inode_id * sector_per_block, + 0, fs->blksz, + (char *)fs->inode_bmaps[i]); + if (status == 0) + goto fail; + } + + /* + *check filesystem consistency with free blocks of file system + *some time we observed that superblock freeblocks does not match + *with the blockgroups freeblocks when improper + *reboot of a linux kernel + */ + for (i = 0; i < fs->no_blkgrp; i++) + real_free_blocks = real_free_blocks + fs->gd[i].free_blocks; + if (real_free_blocks != fs->sb->free_blocks) + fs->sb->free_blocks = real_free_blocks; + return 0; + +fail: + ext4fs_deinit(); + return -1; +} + +void ext4fs_deinit(void) +{ + int i; + struct ext2_inode inode_journal; + struct journal_superblock_t *jsb; + long int blknr; + struct ext_filesystem *fs = get_fs(); + /*free journal */ + char *temp_buff = (char *)xzalloc(fs->blksz); + if (temp_buff) { + ext4fs_read_inode(ext4fs_root, EXT2_JOURNAL_INO, + &inode_journal); + blknr = + read_allocated_block(&inode_journal, + EXT2_JOURNAL_SUPERBLOCK); + ext2fs_devread(blknr * fs->sect_perblk, 0, fs->blksz, + temp_buff); + jsb = (struct journal_superblock_t *)temp_buff; + jsb->s_start = le_be(0); + put_ext4((uint64_t) (blknr * fs->blksz), + (struct journal_superblock_t *)temp_buff, + (uint32_t) fs->blksz); + free(temp_buff); + } + free_journal(); + /*get the superblock */ + ext2fs_devread(SUPERBLOCK_SECTOR, 0, SUPERBLOCK_SIZE, (char *)fs->sb); + fs->sb->feature_incompat &= ~EXT3_FEATURE_INCOMPAT_RECOVER; + put_ext4((uint64_t) (SUPERBLOCK_SIZE), + (struct ext2_sblock *)fs->sb, (uint32_t) SUPERBLOCK_SIZE); + if (fs->sb) { + free(fs->sb); + fs->sb = NULL; + } + + if (fs->blk_bmaps) { + for (i = 0; i < fs->no_blkgrp; i++) { + if (fs->blk_bmaps[i]) { + free(fs->blk_bmaps[i]); + fs->blk_bmaps[i] = NULL; + } + } + free(fs->blk_bmaps); + fs->blk_bmaps = NULL; + } + + if (fs->inode_bmaps) { + for (i = 0; i < fs->no_blkgrp; i++) { + if (fs->inode_bmaps[i]) { + free(fs->inode_bmaps[i]); + fs->inode_bmaps[i] = NULL; + } + } + free(fs->inode_bmaps); + fs->inode_bmaps = NULL; + } + + if (fs->gdtable) { + free(fs->gdtable); + fs->gdtable = NULL; + } + fs->gd = NULL; + /* + *Reinitiliazed the global inode and + *block bitmap first execution check variables + */ + fs->first_pass_ibmap = 0; + fs->first_pass_bbmap = 0; + fs->curr_inode_no = 0; + fs->curr_blkno = 0; + + return; +} + +static int ext4fs_write_file(struct ext2_inode *file_inode, + int pos, unsigned int len, char *buf) +{ + int i; + int blockcnt; + int log2blocksize = LOG2_EXT2_BLOCK_SIZE(ext4fs_root); + unsigned int filesize = __le32_to_cpu(file_inode->size); + struct ext_filesystem *fs = get_fs(); + int previous_block_number = -1; + int delayed_start = 0; + int delayed_extent = 0; + int delayed_skipfirst = 0; + int delayed_next = 0; + char *delayed_buf = NULL; + + /* Adjust len so it we can't read past the end of the file. */ + if (len > filesize) + len = filesize; + + blockcnt = ((len + pos) + fs->blksz - 1) / fs->blksz; + + for (i = pos / fs->blksz; i < blockcnt; i++) { + long int blknr; + int blockend = fs->blksz; + int skipfirst = 0; + blknr = read_allocated_block(file_inode, i); + if (blknr < 0) + return -1; + + blknr = blknr << log2blocksize; + + if (blknr) { + if (previous_block_number != -1) { + if (delayed_next == blknr) { + delayed_extent += blockend; + delayed_next += blockend >> SECTOR_BITS; + } else { /* spill */ + put_ext4((uint64_t) (delayed_start * + SECTOR_SIZE), + delayed_buf, + (uint32_t) delayed_extent); + previous_block_number = blknr; + delayed_start = blknr; + delayed_extent = blockend; + delayed_skipfirst = skipfirst; + delayed_buf = buf; + delayed_next = blknr + + (blockend >> SECTOR_BITS); + } + } else { + previous_block_number = blknr; + delayed_start = blknr; + delayed_extent = blockend; + delayed_skipfirst = skipfirst; + delayed_buf = buf; + delayed_next = blknr + + (blockend >> SECTOR_BITS); + } + } else { + if (previous_block_number != -1) { + /* spill */ + put_ext4((uint64_t) (delayed_start * + SECTOR_SIZE), delayed_buf, + (uint32_t) delayed_extent); + previous_block_number = -1; + } + memset(buf, 0, fs->blksz - skipfirst); + } + buf += fs->blksz - skipfirst; + } + if (previous_block_number != -1) { + /* spill */ + put_ext4((uint64_t) (delayed_start * SECTOR_SIZE), + delayed_buf, (uint32_t) delayed_extent); + previous_block_number = -1; + } + return len; +} + +int ext4fs_write(char *fname, unsigned char *buffer, unsigned long sizebytes) +{ + int ret = 0; + /*inode */ + struct ext2_inode *file_inode = NULL; + unsigned char *inode_buffer = NULL; + int parent_inodeno; + int inodeno; + time_t timestamp = 0; + + /*filesize */ + uint64_t total_no_of_bytes_for_file; + unsigned int total_no_of_block_for_file; + unsigned int total_remaining_blocks; + int existing_file_inodeno; + char filename[256]; + + char *temp_ptr = NULL; + long int itable_blkno, parent_itable_blkno, blkoff; + struct ext2_sblock *sblock = &(ext4fs_root->sblock); + unsigned int inodes_per_block; + unsigned int inode_bitmap_index; + struct ext_filesystem *fs = get_fs(); + + g_parent_inode = (struct ext2_inode *) + xzalloc(sizeof(struct ext2_inode)); + if (!g_parent_inode) + goto fail; + + if (ext4fs_init() != 0) { + printf("error in File System init\n"); + return -1; + } + inodes_per_block = fs->blksz / fs->inodesz; + parent_inodeno = get_parent_inode_num(fname, filename, F_FILE); + if (parent_inodeno == -1) + goto fail; + if (iget(parent_inodeno, g_parent_inode)) + goto fail; + /*check if the filename is already present in root */ + existing_file_inodeno = ext4fs_filename_check(filename); + if (existing_file_inodeno != -1) { + ret = ext4fs_delete_file(existing_file_inodeno); + fs->first_pass_bbmap = 0; + fs->curr_blkno = 0; + + fs->first_pass_ibmap = 0; + fs->curr_inode_no = 0; + if (ret) + goto fail; + } + /*calucalate how many blocks required */ + total_no_of_bytes_for_file = sizebytes; + total_no_of_block_for_file = total_no_of_bytes_for_file / fs->blksz; + if (total_no_of_bytes_for_file % fs->blksz != 0) { + total_no_of_block_for_file++; + debug("total bytes for a file %u\n", + total_no_of_block_for_file); + } + total_remaining_blocks = total_no_of_block_for_file; + /*Test for available space in partition */ + if (fs->sb->free_blocks < total_no_of_block_for_file) { + printf("Not enough space on partition !!!\n"); + goto fail; + } + + update_parent_dentry(filename, &inodeno, FILETYPE_REG); + /*prepare file inode */ + inode_buffer = xmalloc(fs->inodesz); + memset(inode_buffer, '\0', fs->inodesz); + file_inode = (struct ext2_inode *)inode_buffer; + file_inode->mode = S_IFREG | S_IRWXU | + S_IRGRP | S_IROTH | S_IXGRP | S_IXOTH; + /* ToDo: Update correct time */ + file_inode->mtime = timestamp; + file_inode->atime = timestamp; + file_inode->ctime = timestamp; + file_inode->nlinks = 1; + file_inode->size = sizebytes; + + /* Allocate data blocks */ + allocate_blocks(file_inode, total_remaining_blocks, + &total_no_of_block_for_file); + /* + *write the inode to inode table after last filled inode in inode table + *we are using hardcoded gd[0].inode_table_id becuase 0th blockgroup + *is suffcient to create more than 1000 file.TODO exapnd the logic to + *all blockgroup + */ + file_inode->blockcnt = (total_no_of_block_for_file * fs->blksz) + / SECTOR_SIZE; + + temp_ptr = (char *)xzalloc(fs->blksz); + if (!temp_ptr) + goto fail; + inode_bitmap_index = inodeno / + (uint32_t) ext4fs_root->sblock.inodes_per_group; + inodeno--; + itable_blkno = + __le32_to_cpu(fs->gd[inode_bitmap_index].inode_table_id) + + (inodeno % __le32_to_cpu(sblock->inodes_per_group)) + / inodes_per_block; + blkoff = (inodeno % inodes_per_block) * fs->inodesz; + ext2fs_devread(itable_blkno * fs->sect_perblk, 0, fs->blksz, temp_ptr); + if (log_journal(temp_ptr, itable_blkno)) + goto fail; + + memcpy(temp_ptr + blkoff, inode_buffer, fs->inodesz); + if (put_metadata(temp_ptr, itable_blkno)) + goto fail; + /*Copy the file content into data blocks */ + if (ext4fs_write_file(file_inode, 0, sizebytes, (char *)buffer) == -1) { + printf("Error in copying content\n"); + goto fail; + } + inode_bitmap_index = parent_inodeno / + (uint32_t) ext4fs_root->sblock.inodes_per_group; + parent_inodeno--; + parent_itable_blkno = + __le32_to_cpu(fs->gd[inode_bitmap_index].inode_table_id) + + (parent_inodeno % __le32_to_cpu(sblock->inodes_per_group)) / + inodes_per_block; + blkoff = (parent_inodeno % inodes_per_block) * fs->inodesz; + if (parent_itable_blkno != itable_blkno) { + memset(temp_ptr, '\0', fs->blksz); + ext2fs_devread(parent_itable_blkno * fs->sect_perblk, + 0, fs->blksz, temp_ptr); + if (log_journal(temp_ptr, parent_itable_blkno)) + goto fail; + + memcpy(temp_ptr + blkoff, g_parent_inode, + sizeof(struct ext2_inode)); + if (put_metadata(temp_ptr, parent_itable_blkno)) + goto fail; + free(temp_ptr); + } else { + /* If parent and child fall in same inode table block + * both should be kept in 1 buffer + */ + memcpy(temp_ptr + blkoff, g_parent_inode, + sizeof(struct ext2_inode)); + gd_index--; + if (put_metadata(temp_ptr, itable_blkno)) + goto fail; + free(temp_ptr); + } + ext4fs_update(); + ext4fs_deinit(); + + fs->first_pass_bbmap = 0; + fs->curr_blkno = 0; + fs->first_pass_ibmap = 0; + fs->curr_inode_no = 0; + if (inode_buffer) + free(inode_buffer); + if (g_parent_inode) { + free(g_parent_inode); + g_parent_inode = NULL; + } + return 0; + +fail: + ext4fs_deinit(); + if (inode_buffer) + free(inode_buffer); + if (g_parent_inode) { + free(g_parent_inode); + g_parent_inode = NULL; + } + return -1; +} diff --git a/include/ext4fs.h b/include/ext4fs.h index fd7bd47..e4e2c3e 100644 --- a/include/ext4fs.h +++ b/include/ext4fs.h @@ -102,9 +102,17 @@ extern block_dev_desc_t *ext4_dev_desc; extern struct ext2_data *ext4fs_root; extern struct ext2fs_node *ext4fs_file; +extern struct ext2_inode *g_parent_inode; +extern int gd_index; +extern int gindex; + struct ext_filesystem *get_fs(void); int init_fs(block_dev_desc_t *); void deinit_fs(block_dev_desc_t *); +int ext4fs_init(void); +void ext4fs_deinit(void); +int ext4fs_write(char *fname, unsigned char *buffer, unsigned long sizebytes); +int ext4fs_filename_check(char *filename); int ext4fs_open(const char *filename); int ext4fs_read(char *buf, unsigned len); int ext4fs_mount(unsigned part_length); -- 1.7.0.4

5 13

[U-Boot] [PATCH] u-boot: Update yaffs2 file system
by Charles Manning 13 Aug '12

13 Aug '12

This patch updates the yaffs2 in u-boot to correspond to git://www.aleph1.co.uk/yaffs2 commit id 9ee5d0643e559568dbe62215f76e0a7bd5a63d93 Signed-off-by: Charles Manning <cdhmanning(a)gmail.com> --- common/cmd_yaffs2.c | 383 ++- fs/yaffs2/Makefile | 31 +- fs/yaffs2/README-linux | 201 - fs/yaffs2/devextras.h | 275 -- fs/yaffs2/stdio.h | 1 + fs/yaffs2/stdlib.h | 1 + fs/yaffs2/string.h | 6 + fs/yaffs2/yaffs_allocator.c | 357 ++ fs/yaffs2/yaffs_allocator.h | 30 + fs/yaffs2/yaffs_attribs.c | 153 + fs/yaffs2/yaffs_attribs.h | 28 + fs/yaffs2/yaffs_bitmap.c | 97 + fs/yaffs2/yaffs_bitmap.h | 33 + fs/yaffs2/yaffs_checkptrw.c | 525 ++-- fs/yaffs2/yaffs_checkptrw.h | 15 +- fs/yaffs2/yaffs_ecc.c | 148 +- fs/yaffs2/yaffs_ecc.h | 46 +- fs/yaffs2/yaffs_error.c | 58 + fs/yaffs2/yaffs_flashif.h | 24 +- fs/yaffs2/yaffs_flashif2.h | 35 + fs/yaffs2/yaffs_getblockinfo.h | 35 + fs/yaffs2/yaffs_guts.c | 9213 +++++++++++++++------------------------- fs/yaffs2/yaffs_guts.h | 1219 +++--- fs/yaffs2/yaffs_hweight.c | 53 + fs/yaffs2/yaffs_hweight.h | 24 + fs/yaffs2/yaffs_list.h | 126 + fs/yaffs2/yaffs_malloc.h | 25 - fs/yaffs2/yaffs_mtdif.c | 175 +- fs/yaffs2/yaffs_mtdif.h | 12 +- fs/yaffs2/yaffs_mtdif2.c | 270 +- fs/yaffs2/yaffs_mtdif2.h | 17 +- fs/yaffs2/yaffs_nameval.c | 208 + fs/yaffs2/yaffs_nameval.h | 28 + fs/yaffs2/yaffs_nand.c | 150 +- fs/yaffs2/yaffs_nand.h | 31 +- fs/yaffs2/yaffs_nandemul2k.h | 26 +- fs/yaffs2/yaffs_nandif.c | 252 ++ fs/yaffs2/yaffs_nandif.h | 65 + fs/yaffs2/yaffs_osglue.h | 42 + fs/yaffs2/yaffs_packedtags1.c | 63 +- fs/yaffs2/yaffs_packedtags1.h | 24 +- fs/yaffs2/yaffs_packedtags2.c | 268 +- fs/yaffs2/yaffs_packedtags2.h | 35 +- fs/yaffs2/yaffs_qsort.c | 58 +- fs/yaffs2/yaffs_qsort.h | 23 - fs/yaffs2/yaffs_ramdisk.h | 32 - fs/yaffs2/yaffs_summary.c | 313 ++ fs/yaffs2/yaffs_summary.h | 37 + fs/yaffs2/yaffs_tagscompat.c | 573 +-- fs/yaffs2/yaffs_tagscompat.h | 34 +- fs/yaffs2/yaffs_tagsvalidity.c | 31 - fs/yaffs2/yaffs_tagsvalidity.h | 24 - fs/yaffs2/yaffs_trace.h | 57 + fs/yaffs2/yaffs_uboot_glue.c | 464 ++ fs/yaffs2/yaffs_verify.c | 529 +++ fs/yaffs2/yaffs_verify.h | 43 + fs/yaffs2/yaffs_yaffs1.c | 422 ++ fs/yaffs2/yaffs_yaffs1.h | 22 + fs/yaffs2/yaffs_yaffs2.c | 1532 +++++++ fs/yaffs2/yaffs_yaffs2.h | 39 + fs/yaffs2/yaffscfg.c | 420 -- fs/yaffs2/yaffscfg.h | 24 +- fs/yaffs2/yaffsfs.c | 3446 +++++++++++---- fs/yaffs2/yaffsfs.h | 282 +- fs/yaffs2/yaffsinterface.h | 21 - fs/yaffs2/ydirectenv.h | 82 +- fs/yaffs2/yportenv.h | 393 ++- 67 files changed, 13596 insertions(+), 10113 deletions(-) delete mode 100644 fs/yaffs2/README-linux delete mode 100644 fs/yaffs2/devextras.h create mode 100644 fs/yaffs2/stdio.h create mode 100644 fs/yaffs2/stdlib.h create mode 100644 fs/yaffs2/string.h create mode 100644 fs/yaffs2/yaffs_allocator.c create mode 100644 fs/yaffs2/yaffs_allocator.h create mode 100644 fs/yaffs2/yaffs_attribs.c create mode 100644 fs/yaffs2/yaffs_attribs.h create mode 100644 fs/yaffs2/yaffs_bitmap.c create mode 100644 fs/yaffs2/yaffs_bitmap.h create mode 100644 fs/yaffs2/yaffs_error.c create mode 100644 fs/yaffs2/yaffs_flashif2.h create mode 100644 fs/yaffs2/yaffs_getblockinfo.h create mode 100644 fs/yaffs2/yaffs_hweight.c create mode 100644 fs/yaffs2/yaffs_hweight.h create mode 100644 fs/yaffs2/yaffs_list.h delete mode 100644 fs/yaffs2/yaffs_malloc.h create mode 100644 fs/yaffs2/yaffs_nameval.c create mode 100644 fs/yaffs2/yaffs_nameval.h create mode 100644 fs/yaffs2/yaffs_nandif.c create mode 100644 fs/yaffs2/yaffs_nandif.h create mode 100644 fs/yaffs2/yaffs_osglue.h delete mode 100644 fs/yaffs2/yaffs_qsort.h delete mode 100644 fs/yaffs2/yaffs_ramdisk.h create mode 100644 fs/yaffs2/yaffs_summary.c create mode 100644 fs/yaffs2/yaffs_summary.h delete mode 100644 fs/yaffs2/yaffs_tagsvalidity.c delete mode 100644 fs/yaffs2/yaffs_tagsvalidity.h create mode 100644 fs/yaffs2/yaffs_trace.h create mode 100644 fs/yaffs2/yaffs_uboot_glue.c create mode 100644 fs/yaffs2/yaffs_verify.c create mode 100644 fs/yaffs2/yaffs_verify.h create mode 100644 fs/yaffs2/yaffs_yaffs1.c create mode 100644 fs/yaffs2/yaffs_yaffs1.h create mode 100644 fs/yaffs2/yaffs_yaffs2.c create mode 100644 fs/yaffs2/yaffs_yaffs2.h delete mode 100644 fs/yaffs2/yaffscfg.c delete mode 100644 fs/yaffs2/yaffsinterface.h diff --git a/common/cmd_yaffs2.c b/common/cmd_yaffs2.c index 0e22d90..d43a9d4 100644 --- a/common/cmd_yaffs2.c +++ b/common/cmd_yaffs2.c @@ -1,18 +1,37 @@ +/* Yaffs commands. + * Modified by Charles Manning by adding ydevconfig command. + * + * Use ydevconfig to configure a mountpoint before use. + * For example: + * # Configure mountpt xxx using nand device 0 using blocks 100-500 + * ydevconfig xxx 0 100 500 + * # Mount it + * ymount xxx + * # yls, yrdm etc + * yls -l xxx + * yrdm xxx/boot-image 82000000 + * ... + */ + #include <common.h> #include <config.h> #include <command.h> -#ifdef YAFFS2_DEBUG -#define PRINTF(fmt,args...) printf (fmt ,##args) +#ifdef YAFFS2_DEBUG +#define PRINTF(fmt, args...) printf(fmt, ##args) #else -#define PRINTF(fmt,args...) +#define PRINTF(fmt, args...) do { } while (0) #endif +extern void cmd_yaffs_dev_ls(void); +extern void cmd_yaffs_tracemask(unsigned set, unsigned mask); +extern void cmd_yaffs_devconfig(char *mp, int flash_dev, + int start_block, int end_block); extern void cmd_yaffs_mount(char *mp); extern void cmd_yaffs_umount(char *mp); extern void cmd_yaffs_read_file(char *fn); -extern void cmd_yaffs_write_file(char *fn,char bval,int sizeOfFile); +extern void cmd_yaffs_write_file(char *fn, char bval, int sizeOfFile); extern void cmd_yaffs_ls(const char *mountpt, int longlist); extern void cmd_yaffs_mwrite_file(char *fn, char *addr, int size); extern void cmd_yaffs_mread_file(char *fn, char *addr); @@ -21,193 +40,287 @@ extern void cmd_yaffs_rmdir(const char *dir); extern void cmd_yaffs_rm(const char *path); extern void cmd_yaffs_mv(const char *oldPath, const char *newPath); -extern int yaffs_DumpDevStruct(const char *path); +extern int yaffs_dump_dev(const char *path); + +/* ytrace - show/set yaffs trace mask */ +int do_ytrace(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) +{ + if (argc > 1) + cmd_yaffs_tracemask(1, simple_strtol(argv[1], NULL, 16)); + else + cmd_yaffs_tracemask(0, 0); + return 0; +} -int do_ymount (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +/* ydevls - lists yaffs mount points. */ +int do_ydevls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *mtpoint = argv[1]; - cmd_yaffs_mount(mtpoint); + cmd_yaffs_dev_ls(); - return(0); + return 0; } -int do_yumount (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +/* ydevconfig mount_pt mtd_dev_num start_block end_block */ +int do_ydevconfig(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *mtpoint = argv[1]; - cmd_yaffs_umount(mtpoint); + char *mtpoint; + int mtd_dev; + int start_block; + int end_block; + + if (argc != 5) { + printf + ("Bad arguments: ydevconfig mount_pt mtd_dev start_block end_block\n"); + return -1; + } + + mtpoint = argv[1]; + mtd_dev = simple_strtol(argv[2], NULL, 16); + start_block = simple_strtol(argv[3], NULL, 16); + end_block = simple_strtol(argv[4], NULL, 16); - return(0); + cmd_yaffs_devconfig(mtpoint, mtd_dev, start_block, end_block); + + return 0; } -int do_yls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_ymount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *dirname = argv[argc-1]; + char *mtpoint; + + if (argc != 2) { + printf("Bad arguments: ymount mount_pt\n"); + return -1; + } + + mtpoint = argv[1]; + printf("Mounting yaffs2 mount point %s\n", mtpoint); - cmd_yaffs_ls(dirname, (argc>2)?1:0); + cmd_yaffs_mount(mtpoint); - return(0); + return 0; } -int do_yrd (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_yumount(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *filename = argv[1]; - printf ("Reading file %s ", filename); + char *mtpoint; - cmd_yaffs_read_file(filename); + if (argc != 2) { + printf("Bad arguments: yumount mount_pt\n"); + return -1; + } - printf ("done\n"); - return(0); + mtpoint = argv[1]; + printf("Unmounting yaffs2 mount point %s\n", mtpoint); + cmd_yaffs_umount(mtpoint); + + return 0; } -int do_ywr (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_yls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *filename = argv[1]; - ulong value = simple_strtoul(argv[2], NULL, 16); - ulong numValues = simple_strtoul(argv[3], NULL, 16); + char *dirname; + + if (argc < 2 || argc > 3 || (argc == 3 && strcmp(argv[1], "-l"))) { + printf("Bad arguments: yls [-l] dir\n"); + return -1; + } - printf ("Writing value (%lx) %lx times to %s... ", value, numValues, filename); + dirname = argv[argc - 1]; - cmd_yaffs_write_file(filename,value,numValues); + cmd_yaffs_ls(dirname, (argc > 2) ? 1 : 0); - printf ("done\n"); - return(0); + return 0; } -int do_yrdm (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_yrd(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *filename = argv[1]; - ulong addr = simple_strtoul(argv[2], NULL, 16); + char *filename; + + if (argc != 2) { + printf("Bad arguments: yrd file_name\n"); + return -1; + } - cmd_yaffs_mread_file(filename, (char *)addr); + filename = argv[1]; - return(0); + printf("Reading file %s ", filename); + + cmd_yaffs_read_file(filename); + + printf("done\n"); + return 0; } -int do_ywrm (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_ywr(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *filename = argv[1]; - ulong addr = simple_strtoul(argv[2], NULL, 16); - ulong size = simple_strtoul(argv[3], NULL, 16); + char *filename; + ulong value; + ulong numValues; + + if (argc != 4) { + printf("Bad arguments: ywr file_name value n_values\n"); + return -1; + } - cmd_yaffs_mwrite_file(filename, (char *)addr, size); + filename = argv[1]; + value = simple_strtoul(argv[2], NULL, 16); + numValues = simple_strtoul(argv[3], NULL, 16); - return(0); + printf("Writing value (%lx) %lx times to %s... ", value, numValues, + filename); + + cmd_yaffs_write_file(filename, value, numValues); + + printf("done\n"); + return 0; } -int do_ymkdir (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_yrdm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *dirname = argv[1]; + char *filename; + ulong addr; + + if (argc != 3) { + printf("Bad arguments: yrdm file_name addr\n"); + return -1; + } - cmd_yaffs_mkdir(dirname); + filename = argv[1]; + addr = simple_strtoul(argv[2], NULL, 16); - return(0); + cmd_yaffs_mread_file(filename, (char *)addr); + + return 0; } -int do_yrmdir (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_ywrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *dirname = argv[1]; + char *filename; + ulong addr; + ulong size; + + if (argc != 4) { + printf("Bad arguments: ywrm file_name addr size\n"); + return -1; + } + + filename = argv[1]; + addr = simple_strtoul(argv[2], NULL, 16); + size = simple_strtoul(argv[3], NULL, 16); - cmd_yaffs_rmdir(dirname); + cmd_yaffs_mwrite_file(filename, (char *)addr, size); - return(0); + return 0; } -int do_yrm (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_ymkdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *path = argv[1]; + char *dirname; - cmd_yaffs_rm(path); + if (argc != 2) { + printf("Bad arguments: ymkdir dir_name\n"); + return -1; + } - return(0); + dirname = argv[1]; + cmd_yaffs_mkdir(dirname); + + return 0; } -int do_ymv (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_yrmdir(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *oldPath = argv[1]; - char *newPath = argv[2]; + char *dirname; + + if (argc != 2) { + printf("Bad arguments: yrmdir dir_name\n"); + return -1; + } - cmd_yaffs_mv(newPath, oldPath); + dirname = argv[1]; + cmd_yaffs_rmdir(dirname); - return(0); + return 0; } -int do_ydump (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) +int do_yrm(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { - char *dirname = argv[1]; - if (yaffs_DumpDevStruct(dirname) != 0) - printf("yaffs_DumpDevStruct returning error when dumping path: , %s\n", dirname); - return 0; + char *name; + + if (argc != 2) { + printf("Bad arguments: yrm name\n"); + return -1; + } + + name = argv[1]; + + cmd_yaffs_rm(name); + + return 0; +} + +int do_ymv(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) +{ + char *oldPath; + char *newPath; + + if (argc != 3) { + printf("Bad arguments: ymv old_path new_path\n"); + return -1; + } + + oldPath = argv[1]; + newPath = argv[2]; + + cmd_yaffs_mv(newPath, oldPath); + + return 0; } -U_BOOT_CMD( - ymount, 3, 0, do_ymount, - "mount yaffs", - "" -); - -U_BOOT_CMD( - yumount, 3, 0, do_yumount, - "unmount yaffs", - "" -); - -U_BOOT_CMD( - yls, 4, 0, do_yls, - "yaffs ls", - "[-l] name" -); - -U_BOOT_CMD( - yrd, 2, 0, do_yrd, - "read file from yaffs", - "filename" -); - -U_BOOT_CMD( - ywr, 4, 0, do_ywr, - "write file to yaffs", - "filename value num_vlues" -); - -U_BOOT_CMD( - yrdm, 3, 0, do_yrdm, - "read file to memory from yaffs", - "filename offset" -); - -U_BOOT_CMD( - ywrm, 4, 0, do_ywrm, - "write file from memory to yaffs", - "filename offset size" -); - -U_BOOT_CMD( - ymkdir, 2, 0, do_ymkdir, - "YAFFS mkdir", - "dirname" -); - -U_BOOT_CMD( - yrmdir, 2, 0, do_yrmdir, - "YAFFS rmdir", - "dirname" -); - -U_BOOT_CMD( - yrm, 2, 0, do_yrm, - "YAFFS rm", - "path" -); - -U_BOOT_CMD( - ymv, 4, 0, do_ymv, - "YAFFS mv", - "oldPath newPath" -); - -U_BOOT_CMD( - ydump, 2, 0, do_ydump, - "YAFFS device struct", - "dirname" -); +U_BOOT_CMD(ytrace, 2, 0, do_ytrace, + "show/set yaffs trace mask", + "ytrace [new_mask] show/set yaffs trace mask"); + +U_BOOT_CMD(ydevls, 1, 0, do_ydevls, + "list yaffs mount points", "list yaffs mount points"); + +U_BOOT_CMD(ydevconfig, 5, 0, do_ydevconfig, + "configure yaffs mount point", + "ydevconfig mtpoint mtd_id start_block end_block configures a yaffs2 mount point"); + +U_BOOT_CMD(ymount, 2, 0, do_ymount, + "mount yaffs", "ymount mtpoint mounts a yaffs2 mount point"); + +U_BOOT_CMD(yumount, 2, 0, do_yumount, + "unmount yaffs", "yunmount mtpoint unmounts a yaffs2 mount point"); + +U_BOOT_CMD(yls, 3, 0, do_yls, "yaffs ls", "yls [-l] dirname"); + +U_BOOT_CMD(yrd, 2, 0, do_yrd, + "read file from yaffs", "yrd path read file from yaffs"); + +U_BOOT_CMD(ywr, 4, 0, do_ywr, + "write file to yaffs", + "ywr filename value num_vlues write values to yaffs file"); + +U_BOOT_CMD(yrdm, 3, 0, do_yrdm, + "read file to memory from yaffs", + "yrdm filename offset reads yaffs file into memory"); + +U_BOOT_CMD(ywrm, 4, 0, do_ywrm, + "write file from memory to yaffs", + "ywrm filename offset size writes memory to yaffs file"); + +U_BOOT_CMD(ymkdir, 2, 0, do_ymkdir, + "YAFFS mkdir", "ymkdir dir create a yaffs directory"); + +U_BOOT_CMD(yrmdir, 2, 0, do_yrmdir, + "YAFFS rmdir", "yrmdir dirname removes a yaffs directory"); + +U_BOOT_CMD(yrm, 2, 0, do_yrm, "YAFFS rm", "yrm path removes a yaffs file"); + +U_BOOT_CMD(ymv, 4, 0, do_ymv, + "YAFFS mv", + "ymv old_path new_path moves/rename files within a yaffs mount point"); diff --git a/fs/yaffs2/Makefile b/fs/yaffs2/Makefile index 904d646..073088d 100644 --- a/fs/yaffs2/Makefile +++ b/fs/yaffs2/Makefile @@ -16,28 +16,43 @@ # # $Id: Makefile,v 1.15 2007/07/18 19:40:38 charles Exp $ -#EXTRA_COMPILE_FLAGS = -DYAFFS_IGNORE_TAGS_ECC include $(TOPDIR)/config.mk LIB = $(obj)libyaffs2.o COBJS-$(CONFIG_YAFFS2) := \ - yaffscfg.o yaffs_ecc.o yaffsfs.o yaffs_guts.o yaffs_packedtags1.o \ - yaffs_tagscompat.o yaffs_packedtags2.o yaffs_tagsvalidity.o \ - yaffs_nand.o yaffs_checkptrw.o yaffs_qsort.o yaffs_mtdif.o \ - yaffs_mtdif2.o + yaffs_allocator.o yaffs_attribs.o yaffs_bitmap.o yaffs_uboot_glue.o\ + yaffs_checkptrw.o yaffs_ecc.o yaffs_error.o \ + yaffsfs.o yaffs_guts.o yaffs_hweight.o yaffs_nameval.o yaffs_nand.o\ + yaffs_packedtags1.o yaffs_packedtags2.o yaffs_qsort.o \ + yaffs_summary.o yaffs_tagscompat.o yaffs_verify.o yaffs_yaffs1.o \ + yaffs_yaffs2.o yaffs_mtdif.o yaffs_mtdif2.o SRCS := $(COBJS-y:.o=.c) OBJS := $(addprefix $(obj),$(COBJS-y)) -# -DCONFIG_YAFFS_NO_YAFFS1 -CFLAGS += -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM -DCONFIG_YAFFS_YAFFS2 -DLINUX_VERSION_CODE=0x20622 +YCFLAGS = -DCONFIG_YAFFS_DIRECT -DCONFIG_YAFFS_SHORT_NAMES_IN_RAM +YCFLAGS += -DCONFIG_YAFFS_YAFFS2 -DNO_Y_INLINE +YCFLAGS += -DCONFIG_YAFFS_PROVIDE_DEFS -DCONFIG_YAFFSFS_PROVIDE_VALUES + +CFLAGS += $(YCFLAGS) +CPPFLAGS += $(YCFLAGS) all: $(LIB) -$(LIB): $(obj).depend $(OBJS) +$(obj)libyaffs2.a: $(obj).depend $(OBJS) + $(AR) $(ARFLAGS) $@ $(OBJS) + +$(obj)libyaffs2.o: $(obj).depend $(OBJS) $(call cmd_link_o_target, $(OBJS)) +.PHONY: clean distclean +clean: + rm -f $(OBJS) + +distclean: clean + rm -f $(LIB) core *.bak .depend + ######################################################################### # defines $(obj).depend target diff --git a/fs/yaffs2/README-linux b/fs/yaffs2/README-linux deleted file mode 100644 index 3851e36..0000000 --- a/fs/yaffs2/README-linux +++ /dev/null @@ -1,201 +0,0 @@ -Welcome to YAFFS, the first file system developed specifically for NAND flash. - -It is now YAFFS2 - original YAFFS (AYFFS1) only supports 512-byte page -NAND and is now deprectated. YAFFS2 supports 512b page in 'YAFFS1 -compatibility' mode (CONFIG_YAFFS_YAFFS1) and 2K or larger page NAND -in YAFFS2 mode (CONFIG_YAFFS_YAFFS2). - - -A note on licencing -------------------- -YAFFS is available under the GPL and via alternative licensing -arrangements with Aleph One. If you're using YAFFS as a Linux kernel -file system then it will be under the GPL. For use in other situations -you should discuss licensing issues with Aleph One. - - -Terminology ------------ -Page - NAND addressable unit (normally 512b or 2Kbyte size) - can - be read, written, marked bad. Has associated OOB. -Block - Eraseable unit. 64 Pages. (128K on 2K NAND, 32K on 512b NAND) -OOB - 'spare area' of each page for ECC, bad block marked and YAFFS - tags. 16 bytes per 512b - 64 bytes for 2K page size. -Chunk - Basic YAFFS addressable unit. Same size as Page. -Object - YAFFS Object: File, Directory, Link, Device etc. - -YAFFS design ------------- - -YAFFS is a log-structured filesystem. It is designed particularly for -NAND (as opposed to NOR) flash, to be flash-friendly, robust due to -journalling, and to have low RAM and boot time overheads. File data is -stored in 'chunks'. Chunks are the same size as NAND pages. Each page -is marked with file id and chunk number. These marking 'tags' are -stored in the OOB (or 'spare') region of the flash. The chunk number -is determined by dividing the file position by the chunk size. Each -chunk has a number of valid bytes, which equals the page size for all -except the last chunk in a file. - -File 'headers' are stored as the first page in a file, marked as a -different type to data pages. The same mechanism is used to store -directories, device files, links etc. The first page describes which -type of object it is. - -YAFFS2 never re-writes a page, because the spec of NAND chips does not -allow it. (YAFFS1 used to mark a block 'deleted' in the OOB). Deletion -is managed by moving deleted objects to the special, hidden 'unlinked' -directory. These records are preserved until all the pages containing -the object have been erased (We know when this happen by keeping a -count of chunks remaining on the system for each object - when it -reaches zero the object really is gone). - -When data in a file is overwritten, the relevant chunks are replaced -by writing new pages to flash containing the new data but the same -tags. - -Pages are also marked with a short (2 bit) serial number that -increments each time the page at this position is incremented. The -reason for this is that if power loss/crash/other act of demonic -forces happens before the replaced page is marked as discarded, it is -possible to have two pages with the same tags. The serial number is -used to arbitrate. - -A block containing only discarded pages (termed a dirty block) is an -obvious candidate for garbage collection. Otherwise valid pages can be -copied off a block thus rendering the whole block discarded and ready -for garbage collection. - -In theory you don't need to hold the file structure in RAM... you -could just scan the whole flash looking for pages when you need them. -In practice though you'd want better file access times than that! The -mechanism proposed here is to have a list of __u16 page addresses -associated with each file. Since there are 2^18 pages in a 128MB NAND, -a __u16 is insufficient to uniquely identify a page but is does -identify a group of 4 pages - a small enough region to search -exhaustively. This mechanism is clearly expandable to larger NAND -devices - within reason. The RAM overhead with this approach is approx -2 bytes per page - 512kB of RAM for a whole 128MB NAND. - -Boot-time scanning to build the file structure lists only requires -one pass reading NAND. If proper shutdowns happen the current RAM -summary of the filesystem status is saved to flash, called -'checkpointing'. This saves re-scanning the flash on startup, and gives -huge boot/mount time savings. - -YAFFS regenerates its state by 'replaying the tape' - i.e. by -scanning the chunks in their allocation order (i.e. block sequence ID -order), which is usually different form the media block order. Each -block is still only read once - starting from the end of the media and -working back. - -YAFFS tags in YAFFS1 mode: - -18-bit Object ID (2^18 files, i.e. > 260,000 files). File id 0- is not - valid and indicates a deleted page. File od 0x3ffff is also not valid. - Synonymous with inode. -2-bit serial number -20-bit Chunk ID within file. Limit of 2^20 chunks/pages per file (i.e. - > 500MB max file size). Chunk ID 0 is the file header for the file. -10-bit counter of the number of bytes used in the page. -12 bit ECC on tags - -YAFFS tags in YAFFS2 mode: - 4 bytes 32-bit chunk ID - 4 bytes 32-bit object ID - 2 bytes Number of data bytes in this chunk - 4 bytes Sequence number for this block - 3 bytes ECC on tags - 12 bytes ECC on data (3 bytes per 256 bytes of data) - - -Page allocation and garbage collection - -Pages are allocated sequentially from the currently selected block. -When all the pages in the block are filled, another clean block is -selected for allocation. At least two or three clean blocks are -reserved for garbage collection purposes. If there are insufficient -clean blocks available, then a dirty block ( ie one containing only -discarded pages) is erased to free it up as a clean block. If no dirty -blocks are available, then the dirtiest block is selected for garbage -collection. - -Garbage collection is performed by copying the valid data pages into -new data pages thus rendering all the pages in this block dirty and -freeing it up for erasure. I also like the idea of selecting a block -at random some small percentage of the time - thus reducing the chance -of wear differences. - -YAFFS is single-threaded. Garbage-collection is done as a parasitic -task of writing data. So each time some data is written, a bit of -pending garbage collection is done. More pages are garbage-collected -when free space is tight. - - -Flash writing - -YAFFS only ever writes each page once, complying with the requirements -of the most restricitve NAND devices. - -Wear levelling - -This comes as a side-effect of the block-allocation strategy. Data is -always written on the next free block, so they are all used equally. -Blocks containing data that is written but never erased will not get -back into the free list, so wear is levelled over only blocks which -are free or become free, not blocks which never change. - - - -Some helpful info ------------------ - -Formatting a YAFFS device is simply done by erasing it. - -Making an initial filesystem can be tricky because YAFFS uses the OOB -and thus the bytes that get written depend on the YAFFS data (tags), -and the ECC bytes and bad block markers which are dictated by the -hardware and/or the MTD subsystem. The data layout also depends on the -device page size (512b or 2K). Because YAFFS is only responsible for -some of the OOB data, generating a filesystem offline requires -detailed knowledge of what the other parts (MTD and NAND -driver/hardware) are going to do. - -To make a YAFFS filesystem you have 3 options: - -1) Boot the system with an empty NAND device mounted as YAFFS and copy - stuff on. - -2) Make a filesystem image offline, then boot the system and use - MTDutils to write an image to flash. - -3) Make a filesystem image offline and use some tool like a bootloader to - write it to flash. - -Option 1 avoids a lot of issues because all the parts -(YAFFS/MTD/hardware) all take care of their own bits and (if you have -put things together properly) it will 'just work'. YAFFS just needs to -know how many bytes of the OOB it can use. However sometimes it is not -practical. - -Option 2 lets MTD/hardware take care of the ECC so the filesystem -image just had to know which bytes to use for YAFFS Tags. - -Option 3 is hardest as the image creator needs to know exactly what -ECC bytes, endianness and algorithm to use as well as which bytes are -available to YAFFS. - -mkyaffs2image creates an image suitable for option 3 for the -particular case of yaffs2 on 2K page NAND with default MTD layout. - -mkyaffsimage creates an equivalent image for 512b page NAND (i.e. -yaffs1 format). - -Bootloaders ------------ - -A bootloader using YAFFS needs to know how MTD is laying out the OOB -so that it can skip bad blocks. - -YAFFS Tracing -------------- diff --git a/fs/yaffs2/devextras.h b/fs/yaffs2/devextras.h deleted file mode 100644 index f6e5361..0000000 --- a/fs/yaffs2/devextras.h +++ /dev/null @@ -1,275 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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 used during development. - * Most of these are from kernel includes placed here so we can use them in - * applications. - * - */ - -#ifndef __EXTRAS_H__ -#define __EXTRAS_H__ - -#if defined WIN32 -#define __inline__ __inline -#define new newHack -#endif - -/* XXX U-BOOT XXX */ -#if 1 /* !(defined __KERNEL__) || (defined WIN32) */ - -/* User space defines */ - -/* XXX U-BOOT XXX */ -#if 0 -typedef unsigned char __u8; -typedef unsigned short __u16; -typedef unsigned __u32; -#endif - -#include <asm/types.h> - -/* - * Simple doubly linked list implementation. - * - * Some of the internal functions ("__xxx") are useful when - * manipulating whole lists rather than single entries, as - * sometimes we already know the next/prev entries and we can - * generate better code by using them directly rather than - * using the generic single-entry routines. - */ - -#define prefetch(x) 1 - -struct list_head { - struct list_head *next, *prev; -}; - -#define LIST_HEAD_INIT(name) { &(name), &(name) } - -#define LIST_HEAD(name) \ - struct list_head name = LIST_HEAD_INIT(name) - -#define INIT_LIST_HEAD(ptr) do { \ - (ptr)->next = (ptr); (ptr)->prev = (ptr); \ -} while (0) - -/* - * Insert a new entry between two known consecutive entries. - * - * This is only for internal list manipulation where we know - * the prev/next entries already! - */ -static __inline__ void __list_add(struct list_head *new, - struct list_head *prev, - struct list_head *next) -{ - next->prev = new; - new->next = next; - new->prev = prev; - prev->next = new; -} - -/** - * list_add - add a new entry - * @new: new entry to be added - * @head: list head to add it after - * - * Insert a new entry after the specified head. - * This is good for implementing stacks. - */ -static __inline__ void list_add(struct list_head *new, struct list_head *head) -{ - __list_add(new, head, head->next); -} - -/** - * list_add_tail - add a new entry - * @new: new entry to be added - * @head: list head to add it before - * - * Insert a new entry before the specified head. - * This is useful for implementing queues. - */ -static __inline__ void list_add_tail(struct list_head *new, - struct list_head *head) -{ - __list_add(new, head->prev, head); -} - -/* - * Delete a list entry by making the prev/next entries - * point to each other. - * - * This is only for internal list manipulation where we know - * the prev/next entries already! - */ -static __inline__ void __list_del(struct list_head *prev, - struct list_head *next) -{ - next->prev = prev; - prev->next = next; -} - -/** - * list_del - deletes entry from list. - * @entry: the element to delete from the list. - * Note: list_empty on entry does not return true after this, the entry is - * in an undefined state. - */ -static __inline__ void list_del(struct list_head *entry) -{ - __list_del(entry->prev, entry->next); -} - -/** - * list_del_init - deletes entry from list and reinitialize it. - * @entry: the element to delete from the list. - */ -static __inline__ void list_del_init(struct list_head *entry) -{ - __list_del(entry->prev, entry->next); - INIT_LIST_HEAD(entry); -} - -/** - * list_empty - tests whether a list is empty - * @head: the list to test. - */ -static __inline__ int list_empty(struct list_head *head) -{ - return head->next == head; -} - -/** - * list_splice - join two lists - * @list: the new list to add. - * @head: the place to add it in the first list. - */ -static __inline__ void list_splice(struct list_head *list, - struct list_head *head) -{ - struct list_head *first = list->next; - - if (first != list) { - struct list_head *last = list->prev; - struct list_head *at = head->next; - - first->prev = head; - head->next = first; - - last->next = at; - at->prev = last; - } -} - -/** - * list_entry - get the struct for this entry - * @ptr: the &struct list_head pointer. - * @type: the type of the struct this is embedded in. - * @member: the name of the list_struct within the struct. - */ -#define list_entry(ptr, type, member) \ - ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) - -/** - * list_for_each - iterate over a list - * @pos: the &struct list_head to use as a loop counter. - * @head: the head for your list. - */ -#define list_for_each(pos, head) \ - for (pos = (head)->next, prefetch(pos->next); pos != (head); \ - pos = pos->next, prefetch(pos->next)) - -/** - * list_for_each_safe - iterate over a list safe against removal - * of list entry - * @pos: the &struct list_head to use as a loop counter. - * @n: another &struct list_head to use as temporary storage - * @head: the head for your list. - */ -#define list_for_each_safe(pos, n, head) \ - for (pos = (head)->next, n = pos->next; pos != (head); \ - pos = n, n = pos->next) - -/* - * 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 -/* XXX U-BOOT XXX */ -#if 0 -#include <sys/stat.h> -#else -#include "common.h" -#endif -#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 -#define ATTR_ATIME_SET 128 -#define ATTR_MTIME_SET 256 -#define ATTR_FORCE 512 /* Not a change, but a change it */ -#define ATTR_ATTR_FLAG 1024 - -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; -}; - -#define KERN_DEBUG - -#else - -#ifndef WIN32 -#include <linux/types.h> -#include <linux/list.h> -#include <linux/fs.h> -#include <linux/stat.h> -#endif - -#endif - -#if defined WIN32 -#undef new -#endif - -#endif diff --git a/fs/yaffs2/stdio.h b/fs/yaffs2/stdio.h new file mode 100644 index 0000000..9f379d7 --- /dev/null +++ b/fs/yaffs2/stdio.h @@ -0,0 +1 @@ +/* Dummy header for u-boot */ diff --git a/fs/yaffs2/stdlib.h b/fs/yaffs2/stdlib.h new file mode 100644 index 0000000..9f379d7 --- /dev/null +++ b/fs/yaffs2/stdlib.h @@ -0,0 +1 @@ +/* Dummy header for u-boot */ diff --git a/fs/yaffs2/string.h b/fs/yaffs2/string.h new file mode 100644 index 0000000..136716a --- /dev/null +++ b/fs/yaffs2/string.h @@ -0,0 +1,6 @@ +#include <linux/stddef.h> +#include <linux/string.h> +#include <linux/stat.h> +#include <common.h> + + diff --git a/fs/yaffs2/yaffs_allocator.c b/fs/yaffs2/yaffs_allocator.c new file mode 100644 index 0000000..c8f2861 --- /dev/null +++ b/fs/yaffs2/yaffs_allocator.c @@ -0,0 +1,357 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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" + +/* + * Each entry in yaffs_tnode_list and yaffs_obj_list hold blocks + * of approx 100 objects that are themn allocated singly. + * This is basically a simplified slab allocator. + * + * We don't use the Linux slab allocator because slab does not allow + * us to dump all the objects in one hit when we do a umount and tear + * down all the tnodes and objects. slab requires that we first free + * the individual objects. + * + * Once yaffs has been mainlined I shall try to motivate for a change + * to slab to provide the extra features we need here. + */ + +struct yaffs_tnode_list { + struct yaffs_tnode_list *next; + struct yaffs_tnode *tnodes; +}; + +struct yaffs_obj_list { + struct yaffs_obj_list *next; + struct yaffs_obj *objects; +}; + +struct yaffs_allocator { + int n_tnodes_created; + struct yaffs_tnode *free_tnodes; + int n_free_tnodes; + struct yaffs_tnode_list *alloc_tnode_list; + + int n_obj_created; + struct list_head free_objs; + int n_free_objects; + + struct yaffs_obj_list *allocated_obj_list; +}; + +static void yaffs_deinit_raw_tnodes(struct yaffs_dev *dev) +{ + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; + struct yaffs_tnode_list *tmp; + + if (!allocator) { + BUG(); + return; + } + + while (allocator->alloc_tnode_list) { + tmp = allocator->alloc_tnode_list->next; + + kfree(allocator->alloc_tnode_list->tnodes); + kfree(allocator->alloc_tnode_list); + allocator->alloc_tnode_list = tmp; + } + + allocator->free_tnodes = NULL; + allocator->n_free_tnodes = 0; + allocator->n_tnodes_created = 0; +} + +static void yaffs_init_raw_tnodes(struct yaffs_dev *dev) +{ + struct yaffs_allocator *allocator = dev->allocator; + + if (!allocator) { + BUG(); + return; + } + + allocator->alloc_tnode_list = NULL; + allocator->free_tnodes = NULL; + allocator->n_free_tnodes = 0; + allocator->n_tnodes_created = 0; +} + +static int yaffs_create_tnodes(struct yaffs_dev *dev, int n_tnodes) +{ + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; + int i; + struct yaffs_tnode *new_tnodes; + u8 *mem; + struct yaffs_tnode *curr; + struct yaffs_tnode *next; + struct yaffs_tnode_list *tnl; + + if (!allocator) { + BUG(); + return YAFFS_FAIL; + } + + if (n_tnodes < 1) + return YAFFS_OK; + + /* make these things */ + new_tnodes = kmalloc(n_tnodes * dev->tnode_size, GFP_NOFS); + mem = (u8 *) new_tnodes; + + if (!new_tnodes) { + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs: Could not allocate Tnodes"); + return YAFFS_FAIL; + } + + /* New hookup for wide tnodes */ + for (i = 0; i < n_tnodes - 1; i++) { + curr = (struct yaffs_tnode *)&mem[i * dev->tnode_size]; + next = (struct yaffs_tnode *)&mem[(i + 1) * dev->tnode_size]; + curr->internal[0] = next; + } + + curr = (struct yaffs_tnode *)&mem[(n_tnodes - 1) * dev->tnode_size]; + curr->internal[0] = allocator->free_tnodes; + allocator->free_tnodes = (struct yaffs_tnode *)mem; + + allocator->n_free_tnodes += n_tnodes; + allocator->n_tnodes_created += n_tnodes; + + /* Now add this bunch of tnodes to a list for freeing up. + * NB If we can't add this to the management list it isn't fatal + * but it just means we can't free this bunch of tnodes later. + */ + tnl = kmalloc(sizeof(struct yaffs_tnode_list), GFP_NOFS); + if (!tnl) { + yaffs_trace(YAFFS_TRACE_ERROR, + "Could not add tnodes to management list"); + return YAFFS_FAIL; + } else { + tnl->tnodes = new_tnodes; + tnl->next = allocator->alloc_tnode_list; + allocator->alloc_tnode_list = tnl; + } + + yaffs_trace(YAFFS_TRACE_ALLOCATE, "Tnodes added"); + + return YAFFS_OK; +} + +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev) +{ + struct yaffs_allocator *allocator = + (struct yaffs_allocator *)dev->allocator; + struct yaffs_tnode *tn = NULL; + + if (!allocator) { + BUG(); + return NULL; + } + + /* If there are none left make more */ + if (!allocator->free_tnodes) + yaffs_create_tnodes(dev, YAFFS_ALLOCATION_NTNODES); + + if (allocator->free_tnodes) { + tn = allocator->free_tnodes; + allocator->free_tnodes = allocator->free_tnodes->internal[0]; + allocator->n_free_tnodes--; + } + + return tn; +} + +/* FreeTnode frees up a tnode and puts it back on the free list */ +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) +{ + struct yaffs_allocator *allocator = dev->allocator; + + if (!allocator) { + BUG(); + return; + } + + if (tn) { + tn->internal[0] = allocator->free_tnodes; + allocator->free_tnodes = tn; + allocator->n_free_tnodes++; + } + dev->checkpoint_blocks_required = 0; /* force recalculation */ +} + +/*--------------- yaffs_obj alloaction ------------------------ + * + * Free yaffs_objs are stored in a list using obj->siblings. + * The blocks of allocated objects are stored in a linked list. + */ + +static void yaffs_init_raw_objs(struct yaffs_dev *dev) +{ + struct yaffs_allocator *allocator = dev->allocator; + + if (!allocator) { + BUG(); + return; + } + + allocator->allocated_obj_list = NULL; + INIT_LIST_HEAD(&allocator->free_objs); + allocator->n_free_objects = 0; +} + +static void yaffs_deinit_raw_objs(struct yaffs_dev *dev) +{ + struct yaffs_allocator *allocator = dev->allocator; + struct yaffs_obj_list *tmp; + + if (!allocator) { + BUG(); + return; + } + + while (allocator->allocated_obj_list) { + tmp = allocator->allocated_obj_list->next; + kfree(allocator->allocated_obj_list->objects); + kfree(allocator->allocated_obj_list); + allocator->allocated_obj_list = tmp; + } + + INIT_LIST_HEAD(&allocator->free_objs); + allocator->n_free_objects = 0; + allocator->n_obj_created = 0; +} + +static int yaffs_create_free_objs(struct yaffs_dev *dev, int n_obj) +{ + struct yaffs_allocator *allocator = dev->allocator; + int i; + struct yaffs_obj *new_objs; + struct yaffs_obj_list *list; + + if (!allocator) { + BUG(); + return YAFFS_FAIL; + } + + if (n_obj < 1) + return YAFFS_OK; + + /* make these things */ + new_objs = kmalloc(n_obj * sizeof(struct yaffs_obj), GFP_NOFS); + list = kmalloc(sizeof(struct yaffs_obj_list), GFP_NOFS); + + if (!new_objs || !list) { + kfree(new_objs); + new_objs = NULL; + kfree(list); + list = NULL; + yaffs_trace(YAFFS_TRACE_ALLOCATE, + "Could not allocate more objects"); + return YAFFS_FAIL; + } + + /* Hook them into the free list */ + for (i = 0; i < n_obj; i++) + list_add(&new_objs[i].siblings, &allocator->free_objs); + + allocator->n_free_objects += n_obj; + allocator->n_obj_created += n_obj; + + /* Now add this bunch of Objects to a list for freeing up. */ + + list->objects = new_objs; + list->next = allocator->allocated_obj_list; + allocator->allocated_obj_list = list; + + return YAFFS_OK; +} + +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev) +{ + struct yaffs_obj *obj = NULL; + struct list_head *lh; + struct yaffs_allocator *allocator = dev->allocator; + + if (!allocator) { + BUG(); + return obj; + } + + /* If there are none left make more */ + if (list_empty(&allocator->free_objs)) + yaffs_create_free_objs(dev, YAFFS_ALLOCATION_NOBJECTS); + + if (!list_empty(&allocator->free_objs)) { + lh = allocator->free_objs.next; + obj = list_entry(lh, struct yaffs_obj, siblings); + list_del_init(lh); + allocator->n_free_objects--; + } + + return obj; +} + +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj) +{ + + struct yaffs_allocator *allocator = dev->allocator; + + if (!allocator) { + BUG(); + return; + } + + /* Link into the free list. */ + list_add(&obj->siblings, &allocator->free_objs); + allocator->n_free_objects++; +} + +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev) +{ + + if (!dev->allocator) { + BUG(); + return; + } + + yaffs_deinit_raw_tnodes(dev); + yaffs_deinit_raw_objs(dev); + kfree(dev->allocator); + dev->allocator = NULL; +} + +void yaffs_init_raw_tnodes_and_objs(struct yaffs_dev *dev) +{ + struct yaffs_allocator *allocator; + + if (dev->allocator) { + BUG(); + return; + } + + allocator = kmalloc(sizeof(struct yaffs_allocator), GFP_NOFS); + if (allocator) { + dev->allocator = allocator; + yaffs_init_raw_tnodes(dev); + yaffs_init_raw_objs(dev); + } +} + diff --git a/fs/yaffs2/yaffs_allocator.h b/fs/yaffs2/yaffs_allocator.h new file mode 100644 index 0000000..a8cc322 --- /dev/null +++ b/fs/yaffs2/yaffs_allocator.h @@ -0,0 +1,30 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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(struct yaffs_dev *dev); +void yaffs_deinit_raw_tnodes_and_objs(struct yaffs_dev *dev); + +struct yaffs_tnode *yaffs_alloc_raw_tnode(struct yaffs_dev *dev); +void yaffs_free_raw_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn); + +struct yaffs_obj *yaffs_alloc_raw_obj(struct yaffs_dev *dev); +void yaffs_free_raw_obj(struct yaffs_dev *dev, struct yaffs_obj *obj); + +#endif diff --git a/fs/yaffs2/yaffs_attribs.c b/fs/yaffs2/yaffs_attribs.c new file mode 100644 index 0000000..648e137 --- /dev/null +++ b/fs/yaffs2/yaffs_attribs.c @@ -0,0 +1,153 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include "yaffs_attribs.h" + + +void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh) +{ + obj->yst_uid = oh->yst_uid; + obj->yst_gid = oh->yst_gid; + obj->yst_atime = oh->yst_atime; + obj->yst_mtime = oh->yst_mtime; + obj->yst_ctime = oh->yst_ctime; + obj->yst_rdev = oh->yst_rdev; +} + + +void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj) +{ +#ifdef CONFIG_YAFFS_WINCE + oh->win_atime[0] = obj->win_atime[0]; + oh->win_ctime[0] = obj->win_ctime[0]; + oh->win_mtime[0] = obj->win_mtime[0]; + oh->win_atime[1] = obj->win_atime[1]; + oh->win_ctime[1] = obj->win_ctime[1]; + oh->win_mtime[1] = obj->win_mtime[1]; +#else + oh->yst_uid = obj->yst_uid; + oh->yst_gid = obj->yst_gid; + oh->yst_atime = obj->yst_atime; + oh->yst_mtime = obj->yst_mtime; + oh->yst_ctime = obj->yst_ctime; + oh->yst_rdev = obj->yst_rdev; +#endif + +} + +void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev) +{ + +#ifdef CONFIG_YAFFS_WINCE + yfsd_win_file_time_now(obj->win_atime); + obj->win_ctime[0] = obj->win_mtime[0] = obj->win_atime[0]; + obj->win_ctime[1] = obj->win_mtime[1] = obj->win_atime[1]; + +#else + yaffs_load_current_time(obj, 1, 1); + obj->yst_rdev = rdev; + obj->yst_uid = uid; + obj->yst_gid = gid; +#endif +} + +void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c) +{ +#ifdef CONFIG_YAFFS_WINCE + yfsd_win_file_time_now(the_obj->win_atime); + the_obj->win_ctime[0] = the_obj->win_mtime[0] = + the_obj->win_atime[0]; + the_obj->win_ctime[1] = the_obj->win_mtime[1] = + the_obj->win_atime[1]; + +#else + + obj->yst_mtime = Y_CURRENT_TIME; + if (do_a) + obj->yst_atime = obj->yst_atime; + if (do_c) + obj->yst_ctime = obj->yst_atime; +#endif +} + +loff_t yaffs_get_file_size(struct yaffs_obj *obj) +{ + YCHAR *alias = NULL; + obj = yaffs_get_equivalent_obj(obj); + + switch (obj->variant_type) { + case YAFFS_OBJECT_TYPE_FILE: + return obj->variant.file_variant.file_size; + case YAFFS_OBJECT_TYPE_SYMLINK: + alias = obj->variant.symlink_variant.alias; + if (!alias) + return 0; + return yaffs_strnlen(alias, YAFFS_MAX_ALIAS_LENGTH); + default: + return 0; + } +} + +int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = attr->ia_valid; + + if (valid & ATTR_MODE) + obj->yst_mode = attr->ia_mode; + if (valid & ATTR_UID) + obj->yst_uid = attr->ia_uid; + if (valid & ATTR_GID) + obj->yst_gid = attr->ia_gid; + + if (valid & ATTR_ATIME) + obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime); + if (valid & ATTR_CTIME) + obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime); + if (valid & ATTR_MTIME) + obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); + + if (valid & ATTR_SIZE) + yaffs_resize_file(obj, attr->ia_size); + + yaffs_update_oh(obj, NULL, 1, 0, 0, NULL); + + return YAFFS_OK; + +} + +int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr) +{ + unsigned int valid = 0; + + attr->ia_mode = obj->yst_mode; + valid |= ATTR_MODE; + attr->ia_uid = obj->yst_uid; + valid |= ATTR_UID; + attr->ia_gid = obj->yst_gid; + valid |= ATTR_GID; + + Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime; + valid |= ATTR_ATIME; + Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime; + valid |= ATTR_CTIME; + Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; + valid |= ATTR_MTIME; + + attr->ia_size = yaffs_get_file_size(obj); + valid |= ATTR_SIZE; + + attr->ia_valid = valid; + + return YAFFS_OK; +} + diff --git a/fs/yaffs2/yaffs_attribs.h b/fs/yaffs2/yaffs_attribs.h new file mode 100644 index 0000000..5b21b08 --- /dev/null +++ b/fs/yaffs2/yaffs_attribs.h @@ -0,0 +1,28 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_ATTRIBS_H__ +#define __YAFFS_ATTRIBS_H__ + +#include "yaffs_guts.h" + +void yaffs_load_attribs(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh); +void yaffs_load_attribs_oh(struct yaffs_obj_hdr *oh, struct yaffs_obj *obj); +void yaffs_attribs_init(struct yaffs_obj *obj, u32 gid, u32 uid, u32 rdev); +void yaffs_load_current_time(struct yaffs_obj *obj, int do_a, int do_c); +int yaffs_set_attribs(struct yaffs_obj *obj, struct iattr *attr); +int yaffs_get_attribs(struct yaffs_obj *obj, struct iattr *attr); + +#endif diff --git a/fs/yaffs2/yaffs_bitmap.c b/fs/yaffs2/yaffs_bitmap.c new file mode 100644 index 0000000..4440e93 --- /dev/null +++ b/fs/yaffs2/yaffs_bitmap.c @@ -0,0 +1,97 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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 inline u8 *yaffs_block_bits(struct yaffs_dev *dev, int blk) +{ + if (blk < dev->internal_start_block || blk > dev->internal_end_block) { + yaffs_trace(YAFFS_TRACE_ERROR, + "BlockBits block %d is not valid", + blk); + BUG(); + } + return dev->chunk_bits + + (dev->chunk_bit_stride * (blk - dev->internal_start_block)); +} + +void yaffs_verify_chunk_bit_id(struct yaffs_dev *dev, int blk, int chunk) +{ + if (blk < dev->internal_start_block || blk > dev->internal_end_block || + chunk < 0 || chunk >= dev->param.chunks_per_block) { + yaffs_trace(YAFFS_TRACE_ERROR, + "Chunk Id (%d:%d) invalid", + blk, chunk); + BUG(); + } +} + +void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk) +{ + u8 *blk_bits = yaffs_block_bits(dev, blk); + + memset(blk_bits, 0, dev->chunk_bit_stride); +} + +void yaffs_clear_chunk_bit(struct yaffs_dev *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(struct yaffs_dev *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(struct yaffs_dev *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(struct yaffs_dev *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(struct yaffs_dev *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++, blk_bits++) + n += hweight8(*blk_bits); + + return n; +} diff --git a/fs/yaffs2/yaffs_bitmap.h b/fs/yaffs2/yaffs_bitmap.h new file mode 100644 index 0000000..e26b37d --- /dev/null +++ b/fs/yaffs2/yaffs_bitmap.h @@ -0,0 +1,33 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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(struct yaffs_dev *dev, int blk, int chunk); +void yaffs_clear_chunk_bits(struct yaffs_dev *dev, int blk); +void yaffs_clear_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +void yaffs_set_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +int yaffs_check_chunk_bit(struct yaffs_dev *dev, int blk, int chunk); +int yaffs_still_some_chunks(struct yaffs_dev *dev, int blk); +int yaffs_count_chunk_bits(struct yaffs_dev *dev, int blk); + +#endif diff --git a/fs/yaffs2/yaffs_checkptrw.c b/fs/yaffs2/yaffs_checkptrw.c index 230f78f..997a618 100644 --- a/fs/yaffs2/yaffs_checkptrw.c +++ b/fs/yaffs2/yaffs_checkptrw.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -11,395 +11,398 @@ * published by the Free Software Foundation. */ -/* XXX U-BOOT XXX */ -#include <common.h> -#include <malloc.h> - -const char *yaffs_checkptrw_c_version = - "$Id: yaffs_checkptrw.c,v 1.14 2007/05/15 20:07:40 charles Exp $"; - - #include "yaffs_checkptrw.h" +#include "yaffs_getblockinfo.h" - -static int yaffs_CheckpointSpaceOk(yaffs_Device *dev) +static int yaffs2_checkpt_space_ok(struct yaffs_dev *dev) { + int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; - int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks; + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "checkpt blocks_avail = %d", blocks_avail); - T(YAFFS_TRACE_CHECKPOINT, - (TSTR("checkpt blocks available = %d" TENDSTR), - blocksAvailable)); - - - return (blocksAvailable <= 0) ? 0 : 1; + return (blocks_avail <= 0) ? 0 : 1; } - -static int yaffs_CheckpointErase(yaffs_Device *dev) +static int yaffs_checkpt_erase(struct yaffs_dev *dev) { - int i; - - if(!dev->eraseBlockInNAND) + if (!dev->param.erase_fn) return 0; - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR), - dev->internalStartBlock,dev->internalEndBlock)); - - for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i); - if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt block %d"TENDSTR),i)); - if(dev->eraseBlockInNAND(dev,i- dev->blockOffset /* realign */)){ - bi->blockState = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; - dev->nFreeChunks += dev->nChunksPerBlock; - } - else { - dev->markNANDBlockBad(dev,i); - bi->blockState = YAFFS_BLOCK_STATE_DEAD; + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "checking blocks %d to %d", + dev->internal_start_block, dev->internal_end_block); + + for (i = dev->internal_start_block; i <= dev->internal_end_block; i++) { + struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); + if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "erasing checkpt block %d", 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->blocksInCheckpoint = 0; + dev->blocks_in_checkpt = 0; return 1; } - -static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev) +static void yaffs2_checkpt_find_erased_block(struct yaffs_dev *dev) { - int i; - int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks; - T(YAFFS_TRACE_CHECKPOINT, - (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR), - dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock)); - - if(dev->checkpointNextBlock >= 0 && - dev->checkpointNextBlock <= dev->internalEndBlock && - blocksAvailable > 0){ - - for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){ - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i); - if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){ - dev->checkpointNextBlock = i + 1; - dev->checkpointCurrentBlock = i; - T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i)); + int i; + int blocks_avail = dev->n_erased_blocks - dev->param.n_reserved_blocks; + + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "allocating checkpt block: erased %d reserved %d avail %d next %d ", + 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++) { + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, i); + if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { + dev->checkpt_next_block = i + 1; + dev->checkpt_cur_block = i; + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "allocating checkpt block %d", i); return; } } } - T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR))); + yaffs_trace(YAFFS_TRACE_CHECKPOINT, "out of checkpt blocks"); - dev->checkpointNextBlock = -1; - dev->checkpointCurrentBlock = -1; + dev->checkpt_next_block = -1; + dev->checkpt_cur_block = -1; } -static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev) +static void yaffs2_checkpt_find_block(struct yaffs_dev *dev) { - int i; - yaffs_ExtendedTags tags; - - T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start: blocks %d next %d" TENDSTR), - dev->blocksInCheckpoint, dev->checkpointNextBlock)); - - if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks) - for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){ - int chunk = i * dev->nChunksPerBlock; - int realignedChunk = chunk - dev->chunkOffset; - - dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags); - T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR), - i, tags.objectId,tags.sequenceNumber,tags.eccResult)); - - if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){ + int i; + struct yaffs_ext_tags tags; + + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "find next checkpt block: start: blocks %d next %d", + 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); + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "find next checkpt block: search: block %d oid %d seq %d eccr %d", + i, tags.obj_id, tags.seq_number, + tags.ecc_result); + + if (tags.seq_number == YAFFS_SEQUENCE_CHECKPOINT_DATA) { /* Right kind of block */ - dev->checkpointNextBlock = tags.objectId; - dev->checkpointCurrentBlock = i; - dev->checkpointBlockList[dev->blocksInCheckpoint] = i; - dev->blocksInCheckpoint++; - T(YAFFS_TRACE_CHECKPOINT,(TSTR("found checkpt block %d"TENDSTR),i)); + 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++; + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "found checkpt block %d", i); return; } } - T(YAFFS_TRACE_CHECKPOINT,(TSTR("found no more checkpt blocks"TENDSTR))); + yaffs_trace(YAFFS_TRACE_CHECKPOINT, "found no more checkpt blocks"); - dev->checkpointNextBlock = -1; - dev->checkpointCurrentBlock = -1; + dev->checkpt_next_block = -1; + dev->checkpt_cur_block = -1; } - -int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting) +int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing) { + int i; + + dev->checkpt_open_write = writing; /* Got the functions we need? */ - if (!dev->writeChunkWithTagsToNAND || - !dev->readChunkWithTagsFromNAND || - !dev->eraseBlockInNAND || - !dev->markNANDBlockBad) + 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(forWriting && !yaffs_CheckpointSpaceOk(dev)) + if (writing && !yaffs2_checkpt_space_ok(dev)) return 0; - if(!dev->checkpointBuffer) - dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk); - if(!dev->checkpointBuffer) + if (!dev->checkpt_buffer) + dev->checkpt_buffer = + kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS); + if (!dev->checkpt_buffer) return 0; - - dev->checkpointPageSequence = 0; - - dev->checkpointOpenForWrite = forWriting; - - dev->checkpointByteCount = 0; - dev->checkpointSum = 0; - dev->checkpointXor = 0; - dev->checkpointCurrentBlock = -1; - dev->checkpointCurrentChunk = -1; - dev->checkpointNextBlock = dev->internalStartBlock; + 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(forWriting){ - memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk); - dev->checkpointByteOffset = 0; - return yaffs_CheckpointErase(dev); + if (writing) { + memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); + dev->checkpt_byte_offs = 0; + return yaffs_checkpt_erase(dev); + } + /* 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 = + kmalloc(sizeof(int) * dev->checkpt_max_blocks, GFP_NOFS); + + if (!dev->checkpt_block_list) + return 0; - } else { - int i; - /* Set to a value that will kick off a read */ - dev->checkpointByteOffset = dev->nDataBytesPerChunk; - /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully) - * going to be way more than we need */ - dev->blocksInCheckpoint = 0; - dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2; - dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks); - for(i = 0; i < dev->checkpointMaxBlocks; i++) - dev->checkpointBlockList[i] = -1; - } + for (i = 0; i < dev->checkpt_max_blocks; i++) + dev->checkpt_block_list[i] = -1; return 1; } -int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum) +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum) { - __u32 compositeSum; - compositeSum = (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF); - *sum = compositeSum; + u32 composite_sum; + + composite_sum = (dev->checkpt_sum << 8) | (dev->checkpt_xor & 0xff); + *sum = composite_sum; return 1; } -static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev) +static int yaffs2_checkpt_flush_buffer(struct yaffs_dev *dev) { - int chunk; - int realignedChunk; - - yaffs_ExtendedTags tags; + int realigned_chunk; + struct yaffs_ext_tags tags; - if(dev->checkpointCurrentBlock < 0){ - yaffs_CheckpointFindNextErasedBlock(dev); - dev->checkpointCurrentChunk = 0; + if (dev->checkpt_cur_block < 0) { + yaffs2_checkpt_find_erased_block(dev); + dev->checkpt_cur_chunk = 0; } - if(dev->checkpointCurrentBlock < 0) + if (dev->checkpt_cur_block < 0) return 0; - tags.chunkDeleted = 0; - tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */ - tags.chunkId = dev->checkpointPageSequence + 1; - tags.sequenceNumber = YAFFS_SEQUENCE_CHECKPOINT_DATA; - tags.byteCount = dev->nDataBytesPerChunk; - if(dev->checkpointCurrentChunk == 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_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointCurrentBlock); - bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; - dev->blocksInCheckpoint++; + struct yaffs_block_info *bi = + yaffs_get_block_info(dev, dev->checkpt_cur_block); + bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; + dev->blocks_in_checkpt++; } - chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk; + chunk = + dev->checkpt_cur_block * dev->param.chunks_per_block + + dev->checkpt_cur_chunk; + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "checkpoint wite buffer nand %d(%d:%d) objid %d chId %d", + chunk, dev->checkpt_cur_block, dev->checkpt_cur_chunk, + tags.obj_id, tags.chunk_id); - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR), - chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId)); + realigned_chunk = chunk - dev->chunk_offset; - realignedChunk = chunk - dev->chunkOffset; + dev->n_page_writes++; - dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags); - dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; - if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){ - dev->checkpointCurrentChunk = 0; - dev->checkpointCurrentBlock = -1; + 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->checkpointBuffer,0,dev->nDataBytesPerChunk); + memset(dev->checkpt_buffer, 0, dev->data_bytes_per_chunk); return 1; } - -int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes) +int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes) { - int i=0; + int i = 0; int ok = 1; + u8 *data_bytes = (u8 *) data; - - __u8 * dataBytes = (__u8 *)data; - - - - if(!dev->checkpointBuffer) + if (!dev->checkpt_buffer) return 0; - if(!dev->checkpointOpenForWrite) + if (!dev->checkpt_open_write) return -1; - while(i < nBytes && ok) { - - - - dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ; - dev->checkpointSum += *dataBytes; - dev->checkpointXor ^= *dataBytes; + 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->checkpointByteOffset++; + dev->checkpt_byte_offs++; i++; - dataBytes++; - dev->checkpointByteCount++; - - - if(dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) - ok = yaffs_CheckpointFlushBuffer(dev); + 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; + return i; } -int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes) +int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes) { - int i=0; + int i = 0; int ok = 1; - yaffs_ExtendedTags tags; - - + struct yaffs_ext_tags tags; int chunk; - int realignedChunk; + int realigned_chunk; + u8 *data_bytes = (u8 *) data; - __u8 *dataBytes = (__u8 *)data; - - if(!dev->checkpointBuffer) + if (!dev->checkpt_buffer) return 0; - if(dev->checkpointOpenForWrite) + if (dev->checkpt_open_write) return -1; - while(i < nBytes && ok) { - + while (i < n_bytes && ok) { - if(dev->checkpointByteOffset < 0 || - dev->checkpointByteOffset >= dev->nDataBytesPerChunk) { + if (dev->checkpt_byte_offs < 0 || + dev->checkpt_byte_offs >= dev->data_bytes_per_chunk) { - if(dev->checkpointCurrentBlock < 0){ - yaffs_CheckpointFindNextCheckpointBlock(dev); - dev->checkpointCurrentChunk = 0; + if (dev->checkpt_cur_block < 0) { + yaffs2_checkpt_find_block(dev); + dev->checkpt_cur_chunk = 0; } - if(dev->checkpointCurrentBlock < 0) + if (dev->checkpt_cur_block < 0) { ok = 0; - else { + break; + } - chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + - dev->checkpointCurrentChunk; + chunk = dev->checkpt_cur_block * + dev->param.chunks_per_block + + dev->checkpt_cur_chunk; - realignedChunk = chunk - dev->chunkOffset; + realigned_chunk = chunk - dev->chunk_offset; + dev->n_page_reads++; - /* read in the next chunk */ - /* printf("read checkpoint page %d\n",dev->checkpointPage); */ - dev->readChunkWithTagsFromNAND(dev, realignedChunk, - dev->checkpointBuffer, - &tags); + /* read in the next chunk */ + dev->param.read_chunk_tags_fn(dev, + realigned_chunk, + dev->checkpt_buffer, + &tags); - if(tags.chunkId != (dev->checkpointPageSequence + 1) || - tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA) - ok = 0; + 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; + break; + } - dev->checkpointByteOffset = 0; - dev->checkpointPageSequence++; - dev->checkpointCurrentChunk++; + dev->checkpt_byte_offs = 0; + dev->checkpt_page_seq++; + dev->checkpt_cur_chunk++; - if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock) - dev->checkpointCurrentBlock = -1; - } + if (dev->checkpt_cur_chunk >= + dev->param.chunks_per_block) + dev->checkpt_cur_block = -1; } - if(ok){ - *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset]; - dev->checkpointSum += *dataBytes; - dev->checkpointXor ^= *dataBytes; - dev->checkpointByteOffset++; - i++; - dataBytes++; - dev->checkpointByteCount++; - } + *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; + return i; } -int yaffs_CheckpointClose(yaffs_Device *dev) +int yaffs_checkpt_close(struct yaffs_dev *dev) { + int i; - if(dev->checkpointOpenForWrite){ - if(dev->checkpointByteOffset != 0) - yaffs_CheckpointFlushBuffer(dev); - } else { - int i; - for(i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++){ - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]); - if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY) - bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT; - else { - // Todo this looks odd... - } + if (dev->checkpt_open_write) { + if (dev->checkpt_byte_offs != 0) + yaffs2_checkpt_flush_buffer(dev); + } else if (dev->checkpt_block_list) { + for (i = 0; + i < dev->blocks_in_checkpt && + dev->checkpt_block_list[i] >= 0; i++) { + int blk = dev->checkpt_block_list[i]; + struct yaffs_block_info *bi = NULL; + + if (dev->internal_start_block <= blk && + blk <= dev->internal_end_block) + bi = yaffs_get_block_info(dev, blk); + if (bi && bi->block_state == YAFFS_BLOCK_STATE_EMPTY) + bi->block_state = YAFFS_BLOCK_STATE_CHECKPOINT; } - YFREE(dev->checkpointBlockList); - dev->checkpointBlockList = NULL; + kfree(dev->checkpt_block_list); + dev->checkpt_block_list = NULL; } - dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock; - dev->nErasedBlocks -= dev->blocksInCheckpoint; + dev->n_free_chunks -= + dev->blocks_in_checkpt * dev->param.chunks_per_block; + dev->n_erased_blocks -= dev->blocks_in_checkpt; + yaffs_trace(YAFFS_TRACE_CHECKPOINT, "checkpoint byte count %d", + dev->checkpt_byte_count); - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR), - dev->checkpointByteCount)); - - if(dev->checkpointBuffer){ + if (dev->checkpt_buffer) { /* free the buffer */ - YFREE(dev->checkpointBuffer); - dev->checkpointBuffer = NULL; + kfree(dev->checkpt_buffer); + dev->checkpt_buffer = NULL; return 1; - } - else + } else { return 0; - + } } -int yaffs_CheckpointInvalidateStream(yaffs_Device *dev) +int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev) { - /* Erase the first checksum block */ - - T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint invalidate"TENDSTR))); + /* Erase the checkpoint data */ - if(!yaffs_CheckpointSpaceOk(dev)) - return 0; + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "checkpoint invalidate of %d blocks", + dev->blocks_in_checkpt); - return yaffs_CheckpointErase(dev); + return yaffs_checkpt_erase(dev); } diff --git a/fs/yaffs2/yaffs_checkptrw.h b/fs/yaffs2/yaffs_checkptrw.h index e59d151..cdbaba7 100644 --- a/fs/yaffs2/yaffs_checkptrw.h +++ b/fs/yaffs2/yaffs_checkptrw.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -18,17 +18,16 @@ #include "yaffs_guts.h" -int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting); +int yaffs2_checkpt_open(struct yaffs_dev *dev, int writing); -int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes); +int yaffs2_checkpt_wr(struct yaffs_dev *dev, const void *data, int n_bytes); -int yaffs_CheckpointRead(yaffs_Device *dev,void *data, int nBytes); +int yaffs2_checkpt_rd(struct yaffs_dev *dev, void *data, int n_bytes); -int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum); +int yaffs2_get_checkpt_sum(struct yaffs_dev *dev, u32 * sum); -int yaffs_CheckpointClose(yaffs_Device *dev); - -int yaffs_CheckpointInvalidateStream(yaffs_Device *dev); +int yaffs_checkpt_close(struct yaffs_dev *dev); +int yaffs2_checkpt_invalidate_stream(struct yaffs_dev *dev); #endif diff --git a/fs/yaffs2/yaffs_ecc.c b/fs/yaffs2/yaffs_ecc.c index 1b4a05d..9294107 100644 --- a/fs/yaffs2/yaffs_ecc.c +++ b/fs/yaffs2/yaffs_ecc.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -16,28 +16,22 @@ * * 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. + * 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. * */ +#include "yportenv.h" + +#include "yaffs_ecc.h" + /* 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. + * Bit 0 of each entry indicates whether the entry has an odd or even parity, + * and therefore this bytes influence on the line parity. */ -/* XXX U-BOOT XXX */ -#include <common.h> - -const char *yaffs_ecc_c_version = - "$Id: yaffs_ecc.c,v 1.9 2007/02/14 01:09:06 wookey Exp $"; - -#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, @@ -73,35 +67,11 @@ static const unsigned char column_parity_table[] = { 0x69, 0x3c, 0x30, 0x65, 0x0c, 0x59, 0x55, 0x00, }; -/* Count the bits in an unsigned char or a U32 */ - -static int yaffs_CountBits(unsigned char x) -{ - int r = 0; - while (x) { - if (x & 1) - r++; - x >>= 1; - } - return r; -} - -static int yaffs_CountBits32(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_ECCCalculate(const unsigned char *data, unsigned char *ecc) +void yaffs_ecc_calc(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; @@ -112,12 +82,10 @@ void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc) b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) // odd number of bits in the byte - { + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; } - } ecc[2] = (~col_parity) | 0x03; @@ -160,19 +128,12 @@ void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc) 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_ECCCorrect(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc) +int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, + const unsigned char *test_ecc) { unsigned char d0, d1, d2; /* deltas */ @@ -181,7 +142,7 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, d2 = read_ecc[2] ^ test_ecc[2]; if ((d0 | d1 | d2) == 0) - return 0; /* no error */ + return 0; /* no error */ if (((d0 ^ (d0 >> 1)) & 0x55) == 0x55 && ((d1 ^ (d1 >> 1)) & 0x55) == 0x55 && @@ -191,15 +152,6 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, 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) @@ -228,19 +180,17 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, data[byte] ^= (1 << bit); - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } - if ((yaffs_CountBits(d0) + - yaffs_CountBits(d1) + - yaffs_CountBits(d2)) == 1) { + if ((hweight8(d0) + hweight8(d1) + hweight8(d2)) == 1) { /* Reccoverable error in ecc */ read_ecc[0] = test_ecc[0]; read_ecc[1] = test_ecc[1]; read_ecc[2] = test_ecc[2]; - return 1; /* Corrected the error */ + return 1; /* Corrected the error */ } /* Unrecoverable error */ @@ -249,25 +199,23 @@ int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, } - /* * ECCxxxOther does ECC calcs on arbitrary n bytes of data */ -void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, - yaffs_ECCOther * eccOther) +void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, + struct 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 < nBytes; i++) { + for (i = 0; i < n_bytes; i++) { b = column_parity_table[*data++]; col_parity ^= b; - if (b & 0x01) { + if (b & 0x01) { /* odd number of bits in the byte */ line_parity ^= i; line_parity_prime ^= ~i; @@ -275,59 +223,59 @@ void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, } - eccOther->colParity = (col_parity >> 2) & 0x3f; - eccOther->lineParity = line_parity; - eccOther->lineParityPrime = line_parity_prime; + ecc_other->col_parity = (col_parity >> 2) & 0x3f; + ecc_other->line_parity = line_parity; + ecc_other->line_parity_prime = line_parity_prime; } -int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes, - yaffs_ECCOther * read_ecc, - const yaffs_ECCOther * test_ecc) +int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc) { - unsigned char cDelta; /* column parity delta */ - unsigned lDelta; /* line parity delta */ - unsigned lDeltaPrime; /* line parity delta */ + unsigned char delta_col; /* column parity delta */ + unsigned delta_line; /* line parity delta */ + unsigned delta_line_prime; /* line parity delta */ unsigned bit; - cDelta = read_ecc->colParity ^ test_ecc->colParity; - lDelta = read_ecc->lineParity ^ test_ecc->lineParity; - lDeltaPrime = read_ecc->lineParityPrime ^ test_ecc->lineParityPrime; + 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 ((cDelta | lDelta | lDeltaPrime) == 0) - return 0; /* no error */ + if ((delta_col | delta_line | delta_line_prime) == 0) + return 0; /* no error */ - if (lDelta == ~lDeltaPrime && - (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15)) - { + if (delta_line == ~delta_line_prime && + (((delta_col ^ (delta_col >> 1)) & 0x15) == 0x15)) { /* Single bit (recoverable) error in data */ bit = 0; - if (cDelta & 0x20) + if (delta_col & 0x20) bit |= 0x04; - if (cDelta & 0x08) + if (delta_col & 0x08) bit |= 0x02; - if (cDelta & 0x02) + if (delta_col & 0x02) bit |= 0x01; - if(lDelta >= nBytes) + if (delta_line >= n_bytes) return -1; - data[lDelta] ^= (1 << bit); + data[delta_line] ^= (1 << bit); - return 1; /* corrected */ + return 1; /* corrected */ } - if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) + - yaffs_CountBits(cDelta)) == 1) { + if ((hweight32(delta_line) + + hweight32(delta_line_prime) + + hweight8(delta_col)) == 1) { /* Reccoverable error in ecc */ *read_ecc = *test_ecc; - return 1; /* corrected */ + return 1; /* corrected */ } /* Unrecoverable error */ return -1; - } diff --git a/fs/yaffs2/yaffs_ecc.h b/fs/yaffs2/yaffs_ecc.h index 79bc3d1..17d47bd 100644 --- a/fs/yaffs2/yaffs_ecc.h +++ b/fs/yaffs2/yaffs_ecc.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -13,32 +13,32 @@ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL. */ - /* - * 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. - * - */ +/* + * 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. + * + */ #ifndef __YAFFS_ECC_H__ #define __YAFFS_ECC_H__ -typedef struct { - unsigned char colParity; - unsigned lineParity; - unsigned lineParityPrime; -} yaffs_ECCOther; +struct yaffs_ecc_other { + unsigned char col_parity; + unsigned line_parity; + unsigned line_parity_prime; +}; -void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc); -int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc, - const unsigned char *test_ecc); +void yaffs_ecc_calc(const unsigned char *data, unsigned char *ecc); +int yaffs_ecc_correct(unsigned char *data, unsigned char *read_ecc, + const unsigned char *test_ecc); -void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes, - yaffs_ECCOther * ecc); -int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes, - yaffs_ECCOther * read_ecc, - const yaffs_ECCOther * test_ecc); +void yaffs_ecc_calc_other(const unsigned char *data, unsigned n_bytes, + struct yaffs_ecc_other *ecc); +int yaffs_ecc_correct_other(unsigned char *data, unsigned n_bytes, + struct yaffs_ecc_other *read_ecc, + const struct yaffs_ecc_other *test_ecc); #endif diff --git a/fs/yaffs2/yaffs_error.c b/fs/yaffs2/yaffs_error.c new file mode 100644 index 0000000..11b75f7 --- /dev/null +++ b/fs/yaffs2/yaffs_error.c @@ -0,0 +1,58 @@ +/* + * YAFFS: Yet another FFS. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Timothy Manning <timothy(a)yaffs.net> + * + * 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 "yaffsfs.h" + +struct error_entry { + int code; + const char *text; +}; + +static const struct error_entry error_list[] = { + { ENOMEM , "ENOMEM" }, + { EBUSY , "EBUSY"}, + { ENODEV , "ENODEV"}, + { EINVAL , "EINVAL"}, + { EBADF , "EBADF"}, + { EACCES , "EACCES"}, + { EXDEV , "EXDEV" }, + { ENOENT , "ENOENT"}, + { ENOSPC , "ENOSPC"}, + { ERANGE , "ERANGE"}, + { ENODATA, "ENODATA"}, + { ENOTEMPTY, "ENOTEMPTY"}, + { ENAMETOOLONG, "ENAMETOOLONG"}, + { ENOMEM , "ENOMEM"}, + { EEXIST , "EEXIST"}, + { ENOTDIR , "ENOTDIR"}, + { EISDIR , "EISDIR"}, + { ENFILE, "ENFILE"}, + { EROFS, "EROFS"}, + { EFAULT, "EFAULT"}, + { 0, NULL } +}; + +const char *yaffs_error_to_str(int err) +{ + const struct error_entry *e = error_list; + + if (err < 0) + err = -err; + + while (e->code && e->text) { + if (err == e->code) + return e->text; + e++; + } + return "Unknown error code"; +} diff --git a/fs/yaffs2/yaffs_flashif.h b/fs/yaffs2/yaffs_flashif.h index 4e5157e..e6e8979 100644 --- a/fs/yaffs2/yaffs_flashif.h +++ b/fs/yaffs2/yaffs_flashif.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -18,14 +18,18 @@ #include "yaffs_guts.h" -int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int yflash_WriteChunkToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, const yaffs_Spare *spare); -int yflash_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags); -int yflash_ReadChunkFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_Spare *spare); -int yflash_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); -int yflash_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int yflash_InitialiseNAND(yaffs_Device *dev); -int yflash_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int yflash_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber); +int yflash_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber); +int yflash_WriteChunkToNAND(struct yaffs_dev *dev, int nand_chunk, + const u8 *data, const struct yaffs_spare *spare); +int yflash_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, int nand_chunk, + const u8 *data, const struct yaffs_ext_tags *tags); +int yflash_ReadChunkFromNAND(struct yaffs_dev *dev, int nand_chunk, + u8 *data, struct yaffs_spare *spare); +int yflash_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, int nand_chunk, + u8 *data, struct yaffs_ext_tags *tags); +int yflash_InitialiseNAND(struct yaffs_dev *dev); +int yflash_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no); +int yflash_QueryNANDBlock(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 *seq_number); #endif diff --git a/fs/yaffs2/yaffs_flashif2.h b/fs/yaffs2/yaffs_flashif2.h new file mode 100644 index 0000000..cfdbde9 --- /dev/null +++ b/fs/yaffs2/yaffs_flashif2.h @@ -0,0 +1,35 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_FLASH2_H__ +#define __YAFFS_FLASH2_H__ + + +#include "yaffs_guts.h" +int yflash2_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber); +int yflash2_WriteChunkToNAND(struct yaffs_dev *dev, int nand_chunk, + const u8 *data, const struct yaffs_spare *spare); +int yflash2_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, int nand_chunk, + const u8 *data, const struct yaffs_ext_tags *tags); +int yflash2_ReadChunkFromNAND(struct yaffs_dev *dev, int nand_chunk, + u8 *data, struct yaffs_spare *spare); +int yflash2_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, int nand_chunk, + u8 *data, struct yaffs_ext_tags *tags); +int yflash2_InitialiseNAND(struct yaffs_dev *dev); +int yflash2_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no); +int yflash2_QueryNANDBlock(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 *seq_number); + +#endif diff --git a/fs/yaffs2/yaffs_getblockinfo.h b/fs/yaffs2/yaffs_getblockinfo.h new file mode 100644 index 0000000..8fd0802 --- /dev/null +++ b/fs/yaffs2/yaffs_getblockinfo.h @@ -0,0 +1,35 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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 inline struct yaffs_block_info *yaffs_get_block_info(struct yaffs_dev + *dev, int blk) +{ + if (blk < dev->internal_start_block || blk > dev->internal_end_block) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>> yaffs: get_block_info block %d is not valid", + blk); + BUG(); + } + return &dev->block_info[blk - dev->internal_start_block]; +} + +#endif diff --git a/fs/yaffs2/yaffs_guts.c b/fs/yaffs2/yaffs_guts.c index 7390b40..00d1c5a 100644 --- a/fs/yaffs2/yaffs_guts.c +++ b/fs/yaffs2/yaffs_guts.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -11,259 +11,176 @@ * published by the Free Software Foundation. */ -/* XXX U-BOOT XXX */ -#include <common.h> - -const char *yaffs_guts_c_version = - "$Id: yaffs_guts.c,v 1.52 2007/10/16 00:45:05 charles Exp $"; - #include "yportenv.h" -#include "linux/stat.h" +#include "yaffs_trace.h" -#include "yaffsinterface.h" -#include "yaffsfs.h" #include "yaffs_guts.h" -#include "yaffs_tagsvalidity.h" - +#include "yaffs_getblockinfo.h" #include "yaffs_tagscompat.h" -#ifndef CONFIG_YAFFS_USE_OWN_SORT -#include "yaffs_qsort.h" -#endif #include "yaffs_nand.h" - -#include "yaffs_checkptrw.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" +#include "yaffs_attribs.h" +#include "yaffs_summary.h" -#include "malloc.h" - -#ifdef CONFIG_YAFFS_WINCE -void yfsd_LockYAFFS(BOOL fsLockOnly); -void yfsd_UnlockYAFFS(BOOL fsLockOnly); -#endif - -#define YAFFS_PASSIVE_GC_CHUNKS 2 +/* 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" +/* Forward declarations */ -/* Robustification (if it ever comes about...) */ -static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND); -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk); -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, - const yaffs_ExtendedTags * tags); -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND, - const yaffs_ExtendedTags * tags); - -/* Other local prototypes */ -static int yaffs_UnlinkObject( yaffs_Object *obj); -static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj); - -static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList); - -static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device * dev, - const __u8 * buffer, - yaffs_ExtendedTags * tags, - int useReserve); -static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode, - int chunkInNAND, int inScan); - -static yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number, - yaffs_ObjectType type); -static void yaffs_AddObjectToDirectory(yaffs_Object * directory, - yaffs_Object * obj); -static int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, - int force, int isShrink, int shadows); -static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj); -static int yaffs_CheckStructures(void); -static int yaffs_DoGenericObjectDeletion(yaffs_Object * in); - -static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo); - -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo); -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer, - int lineNo); - -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND); - -static int yaffs_UnlinkWorker(yaffs_Object * obj); -static void yaffs_DestroyObject(yaffs_Object * obj); - -static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId, - int chunkInObject); +static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, + const u8 *buffer, int n_bytes, int use_reserve); -loff_t yaffs_GetFileSize(yaffs_Object * obj); -static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr); -static void yaffs_VerifyFreeChunks(yaffs_Device * dev); - -static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in); - -#ifdef YAFFS_PARANOID -static int yaffs_CheckFileSanity(yaffs_Object * in); -#else -#define yaffs_CheckFileSanity(in) -#endif +/* Function to calculate chunk and offset */ -static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in); -static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId); +void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, + int *chunk_out, u32 *offset_out) +{ + int chunk; + u32 offset; -static void yaffs_InvalidateCheckpoint(yaffs_Device *dev); + chunk = (u32) (addr >> dev->chunk_shift); -static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode, - yaffs_ExtendedTags * tags); + if (dev->chunk_div == 1) { + /* easy power of 2 case */ + offset = (u32) (addr & dev->chunk_mask); + } else { + /* Non power-of-2 case */ -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos); -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev, - yaffs_FileStructure * fStruct, - __u32 chunkId); + loff_t chunk_base; + chunk /= dev->chunk_div; -/* Function to calculate chunk and offset */ - -static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset) -{ - if(dev->chunkShift){ - /* Easy-peasy power of 2 case */ - *chunk = (__u32)(addr >> dev->chunkShift); - *offset = (__u32)(addr & dev->chunkMask); - } - else if(dev->crumbsPerChunk) - { - /* Case where we're using "crumbs" */ - *offset = (__u32)(addr & dev->crumbMask); - addr >>= dev->crumbShift; - *chunk = ((__u32)addr)/dev->crumbsPerChunk; - *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift); + chunk_base = ((loff_t) chunk) * dev->data_bytes_per_chunk; + offset = (u32) (addr - chunk_base); } - else - YBUG(); + + *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 +/* 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 ShiftsGE(__u32 x) +static inline u32 calc_shifts_ceiling(u32 x) { - int extraBits; - int nShifts; + int extra_bits; + int shifts; - nShifts = extraBits = 0; + shifts = extra_bits = 0; - while(x>1){ - if(x & 1) extraBits++; - x>>=1; - nShifts++; + while (x > 1) { + if (x & 1) + extra_bits++; + x >>= 1; + shifts++; } - if(extraBits) - nShifts++; + if (extra_bits) + shifts++; - return nShifts; + return shifts; } /* Function to return the number of shifts to get a 1 in bit 0 */ -static __u32 ShiftDiv(__u32 x) +static inline u32 calc_shifts(u32 x) { - int nShifts; + u32 shifts; - nShifts = 0; + shifts = 0; - if(!x) return 0; + if (!x) + return 0; - while( !(x&1)){ - x>>=1; - nShifts++; + while (!(x & 1)) { + x >>= 1; + shifts++; } - return nShifts; + return shifts; } - - /* * Temporary buffer manipulations. */ -static int yaffs_InitialiseTempBuffers(yaffs_Device *dev) +static int yaffs_init_tmp_buffers(struct yaffs_dev *dev) { int i; - __u8 *buf = (__u8 *)1; + u8 *buf = (u8 *) 1; - memset(dev->tempBuffer,0,sizeof(dev->tempBuffer)); + memset(dev->temp_buffer, 0, sizeof(dev->temp_buffer)); for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) { - dev->tempBuffer[i].line = 0; /* not in use */ - dev->tempBuffer[i].buffer = buf = - YMALLOC_DMA(dev->nDataBytesPerChunk); + dev->temp_buffer[i].in_use = 0; + buf = kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS); + dev->temp_buffer[i].buffer = buf; } return buf ? YAFFS_OK : YAFFS_FAIL; - } -static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo) +u8 *yaffs_get_temp_buffer(struct yaffs_dev * dev) { - int i, j; - for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].line == 0) { - dev->tempBuffer[i].line = lineNo; - if ((i + 1) > dev->maxTemp) { - dev->maxTemp = i + 1; - for (j = 0; j <= i; j++) - dev->tempBuffer[j].maxLine = - dev->tempBuffer[j].line; - } + int i; - return dev->tempBuffer[i].buffer; - } - } + dev->temp_in_use++; + if (dev->temp_in_use > dev->max_temp) + dev->max_temp = dev->temp_in_use; - T(YAFFS_TRACE_BUFFERS, - (TSTR("Out of temp buffers at line %d, other held by lines:"), - lineNo)); for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line)); + if (dev->temp_buffer[i].in_use == 0) { + dev->temp_buffer[i].in_use = 1; + return dev->temp_buffer[i].buffer; + } } - T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR))); + yaffs_trace(YAFFS_TRACE_BUFFERS, "Out of temp buffers"); /* * If we got here then we have to allocate an unmanaged one * This is not good. */ - dev->unmanagedTempAllocations++; - return YMALLOC(dev->nDataBytesPerChunk); + dev->unmanaged_buffer_allocs++; + return kmalloc(dev->data_bytes_per_chunk, GFP_NOFS); } -static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer, - int lineNo) +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer) { int i; + + dev->temp_in_use--; + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].buffer == buffer) { - dev->tempBuffer[i].line = 0; + if (dev->temp_buffer[i].buffer == buffer) { + dev->temp_buffer[i].in_use = 0; return; } } if (buffer) { /* assume it is an unmanaged one. */ - T(YAFFS_TRACE_BUFFERS, - (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR), - lineNo)); - YFREE(buffer); - dev->unmanagedTempDeallocations++; + yaffs_trace(YAFFS_TRACE_BUFFERS, + "Releasing unmanaged temp buffer"); + kfree(buffer); + dev->unmanaged_buffer_deallocs++; } } @@ -271,621 +188,339 @@ static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer, /* * Determine if we have a managed buffer. */ -int yaffs_IsManagedTempBuffer(yaffs_Device * dev, const __u8 * buffer) +int yaffs_is_managed_tmp_buffer(struct yaffs_dev *dev, const u8 *buffer) { int i; + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - if (dev->tempBuffer[i].buffer == buffer) + if (dev->temp_buffer[i].buffer == buffer) return 1; - } - for (i = 0; i < dev->nShortOpCaches; i++) { - if( dev->srCache[i].data == buffer ) - return 1; - - } + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].data == buffer) + return 1; + } - if (buffer == dev->checkpointBuffer) - return 1; + if (buffer == dev->checkpt_buffer) + return 1; - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR))); - return 0; + yaffs_trace(YAFFS_TRACE_ALWAYS, + "yaffs: unmaged buffer detected."); + return 0; } - - /* - * Chunk bitmap manipulations + * Functions for robustisizing TODO + * */ -static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device * dev, int blk) +static void yaffs_handle_chunk_wr_ok(struct yaffs_dev *dev, int nand_chunk, + const u8 *data, + const struct yaffs_ext_tags *tags) { - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR), - blk)); - YBUG(); - } - return dev->chunkBits + - (dev->chunkBitmapStride * (blk - dev->internalStartBlock)); + dev = dev; + nand_chunk = nand_chunk; + data = data; + tags = tags; } -static Y_INLINE void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk) +static void yaffs_handle_chunk_update(struct yaffs_dev *dev, int nand_chunk, + const struct yaffs_ext_tags *tags) { - if(blk < dev->internalStartBlock || blk > dev->internalEndBlock || - chunk < 0 || chunk >= dev->nChunksPerBlock) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),blk,chunk)); - YBUG(); - } -} - -static Y_INLINE void yaffs_ClearChunkBits(yaffs_Device * dev, int blk) -{ - __u8 *blkBits = yaffs_BlockBits(dev, blk); - - memset(blkBits, 0, dev->chunkBitmapStride); + dev = dev; + nand_chunk = nand_chunk; + tags = tags; } -static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk) +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); + if (!bi->gc_prioritise) { + bi->gc_prioritise = 1; + dev->has_pending_prioritised_gc = 1; + bi->chunk_error_strikes++; - yaffs_VerifyChunkBitId(dev,blk,chunk); + if (bi->chunk_error_strikes > 3) { + bi->needs_retiring = 1; /* Too many stikes, so retire */ + yaffs_trace(YAFFS_TRACE_ALWAYS, + "yaffs: Block struck out"); - blkBits[chunk / 8] &= ~(1 << (chunk & 7)); -} - -static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk) -{ - __u8 *blkBits = yaffs_BlockBits(dev, blk); - - yaffs_VerifyChunkBitId(dev,blk,chunk); - - blkBits[chunk / 8] |= (1 << (chunk & 7)); + } + } } -static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device * dev, int blk, int chunk) +static void yaffs_handle_chunk_wr_error(struct yaffs_dev *dev, int nand_chunk, + int erased_ok) { - __u8 *blkBits = yaffs_BlockBits(dev, blk); - yaffs_VerifyChunkBitId(dev,blk,chunk); + int flash_block = nand_chunk / dev->param.chunks_per_block; + struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); - return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0; -} + yaffs_handle_chunk_error(dev, bi); -static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device * dev, int blk) -{ - __u8 *blkBits = yaffs_BlockBits(dev, blk); - int i; - for (i = 0; i < dev->chunkBitmapStride; i++) { - if (*blkBits) - return 1; - blkBits++; + if (erased_ok) { + /* Was an actual write failure, + * so mark the block for retirement.*/ + bi->needs_retiring = 1; + yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, + "**>> Block %d needs retiring", flash_block); } - return 0; -} - -static int yaffs_CountChunkBits(yaffs_Device * dev, int blk) -{ - __u8 *blkBits = yaffs_BlockBits(dev, blk); - int i; - int n = 0; - for (i = 0; i < dev->chunkBitmapStride; i++) { - __u8 x = *blkBits; - while(x){ - if(x & 1) - n++; - x >>=1; - } - blkBits++; - } - return n; + /* Delete the chunk */ + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); + yaffs_skip_rest_of_block(dev); } /* * Verification code */ -static Y_INLINE int yaffs_SkipVerification(yaffs_Device *dev) -{ - return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); -} - -static Y_INLINE int yaffs_SkipFullVerification(yaffs_Device *dev) -{ - return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL)); -} +/* + * Simple hash function. Needs to have a reasonable spread + */ -static Y_INLINE int yaffs_SkipNANDVerification(yaffs_Device *dev) +static inline int yaffs_hash_fn(int n) { - return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND)); + if (n < 0) + n = -n; + return n % YAFFS_NOBJECT_BUCKETS; } -static const char * blockStateName[] = { -"Unknown", -"Needs scanning", -"Scanning", -"Empty", -"Allocating", -"Full", -"Dirty", -"Checkpoint", -"Collecting", -"Dead" -}; +/* + * Access functions to useful fake objects. + * Note that root might have a presence in NAND if permissions are set. + */ -static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n) +struct yaffs_obj *yaffs_root(struct yaffs_dev *dev) { - int actuallyUsed; - int inUse; - - if(yaffs_SkipVerification(dev)) - return; - - /* Report illegal runtime states */ - if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES) - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState)); - - switch(bi->blockState){ - 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,blockStateName[bi->blockState])); - } - - /* Check pages in use and soft deletions are legal */ - - actuallyUsed = bi->pagesInUse - bi->softDeletions; - - if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock || - bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock || - actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock) - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR), - n,bi->pagesInUse,bi->softDeletions)); - - - /* Check chunk bitmap legal */ - inUse = yaffs_CountChunkBits(dev,n); - if(inUse != bi->pagesInUse) - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR), - n,bi->pagesInUse,inUse)); - - /* Check that the sequence number is valid. - * Ten million is legal, but is very unlikely - */ - if(dev->isYaffs2 && - (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) && - (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 )) - T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR), - n,bi->sequenceNumber)); - + return dev->root_dir; } -static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n) +struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev) { - yaffs_VerifyBlock(dev,bi,n); + return dev->lost_n_found; +} - /* After collection the block should be in the erased state */ - /* TODO: This will need to change if we do partial gc */ +/* + * Erased NAND checking functions + */ - if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){ - T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR), - n,bi->blockState)); +int yaffs_check_ff(u8 *buffer, int n_bytes) +{ + /* Horrible, slow implementation */ + while (n_bytes--) { + if (*buffer != 0xff) + return 0; + buffer++; } + return 1; } -static void yaffs_VerifyBlocks(yaffs_Device *dev) +static int yaffs_check_chunk_erased(struct yaffs_dev *dev, int nand_chunk) { - int i; - int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES]; - int nIllegalBlockStates = 0; - - - if(yaffs_SkipVerification(dev)) - return; - - memset(nBlocksPerState,0,sizeof(nBlocksPerState)); - + int retval = YAFFS_OK; + u8 *data = yaffs_get_temp_buffer(dev); + struct yaffs_ext_tags tags; + int result; - for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){ - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i); - yaffs_VerifyBlock(dev,bi,i); + result = yaffs_rd_chunk_tags_nand(dev, nand_chunk, data, &tags); - if(bi->blockState >=0 && bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES) - nBlocksPerState[bi->blockState]++; - else - nIllegalBlockStates++; + 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) { + yaffs_trace(YAFFS_TRACE_NANDACCESS, + "Chunk %d not erased", nand_chunk); + retval = YAFFS_FAIL; } - 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),nIllegalBlockStates)); - if(nBlocksPerState[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), - blockStateName[i],nBlocksPerState[i])); + yaffs_release_temp_buffer(dev, data); - if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]) - T(YAFFS_TRACE_VERIFY, - (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR), - dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])); - - if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]) - T(YAFFS_TRACE_VERIFY, - (TSTR("Erased block count wrong dev %d count %d"TENDSTR), - dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])); - - if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1) - T(YAFFS_TRACE_VERIFY, - (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR), - nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING])); - - T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR))); + return retval; } -/* - * Verify the object header. oh must be valid, but obj and tags may be NULL in which - * case those tests will not be performed. - */ -static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck) +static int yaffs_verify_chunk_written(struct yaffs_dev *dev, + int nand_chunk, + const u8 *data, + struct yaffs_ext_tags *tags) { - if(yaffs_SkipVerification(obj->myDev)) - return; - - if(!(tags && obj && oh)){ - T(YAFFS_TRACE_VERIFY, - (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR), - (__u32)tags,(__u32)obj,(__u32)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->objectId, oh->type)); - - if(tags->objectId != obj->objectId) - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch objectId %d"TENDSTR), - tags->objectId, obj->objectId)); + int retval = YAFFS_OK; + struct yaffs_ext_tags temp_tags; + u8 *buffer = yaffs_get_temp_buffer(dev); + 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); - /* - * Check that the object's parent ids match if parentCheck requested. - * - * Tests do not apply to the root object. - */ - - if(parentCheck && tags->objectId > 1 && !obj->parent) - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR), - tags->objectId, oh->parentObjectId)); + return retval; +} - if(parentCheck && obj->parent && - oh->parentObjectId != obj->parent->objectId && - (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED || - obj->parent->objectId != YAFFS_OBJECTID_DELETED)) - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR), - tags->objectId, oh->parentObjectId, obj->parent->objectId)); +int yaffs_check_alloc_available(struct yaffs_dev *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); - if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */ - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is NULL"TENDSTR), - obj->objectId)); + reserved_chunks = + (reserved_blocks + checkpt_blocks) * dev->param.chunks_per_block; - if(tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */ - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d header name is 0xFF"TENDSTR), - obj->objectId)); + return (dev->n_free_chunks > (reserved_chunks + n_chunks)); } -static void yaffs_VerifyFile(yaffs_Object *obj) +static int yaffs_find_alloc_block(struct yaffs_dev *dev) { - int requiredTallness; - int actualTallness; - __u32 lastChunk; - __u32 x; - __u32 i; - yaffs_Device *dev; - yaffs_ExtendedTags tags; - yaffs_Tnode *tn; - __u32 objectId; - - if(obj && yaffs_SkipVerification(obj->myDev)) - return; + int i; + struct yaffs_block_info *bi; - dev = obj->myDev; - objectId = obj->objectId; + if (dev->n_erased_blocks < 1) { + /* Hoosterman we've got a problem. + * Can't get space to gc + */ + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy: no more erased blocks"); - /* Check file size is consistent with tnode depth */ - lastChunk = obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1; - x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; - while (x> 0) { - x >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; + return -1; } - actualTallness = obj->variant.fileVariant.topLevel; - - if(requiredTallness > actualTallness ) - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR), - obj->objectId,actualTallness, requiredTallness)); - - - /* 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_SkipNANDVerification(dev)) - return; + /* Find an empty block. */ - for(i = 1; i <= lastChunk; i++){ - tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i); - - if (tn) { - __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i); - if(theChunk > 0){ - /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */ - yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags); - if(tags.objectId != objectId || tags.chunkId != i){ - T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR), - objectId, i, theChunk, - tags.objectId, tags.chunkId)); - } - } + 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--; + yaffs_trace(YAFFS_TRACE_ALLOCATE, + "Allocated block %d, seq %d, %d left" , + dev->alloc_block_finder, dev->seq_number, + dev->n_erased_blocks); + return dev->alloc_block_finder; + } } -} - -static void yaffs_VerifyDirectory(yaffs_Object *obj) -{ - if(obj && yaffs_SkipVerification(obj->myDev)) - return; - -} - -static void yaffs_VerifyHardLink(yaffs_Object *obj) -{ - if(obj && yaffs_SkipVerification(obj->myDev)) - return; - - /* Verify sane equivalent object */ -} + yaffs_trace(YAFFS_TRACE_ALWAYS, + "yaffs tragedy: no more erased blocks, but there should have been %d", + dev->n_erased_blocks); -static void yaffs_VerifySymlink(yaffs_Object *obj) -{ - if(obj && yaffs_SkipVerification(obj->myDev)) - return; - - /* Verify symlink string */ -} - -static void yaffs_VerifySpecial(yaffs_Object *obj) -{ - if(obj && yaffs_SkipVerification(obj->myDev)) - return; + return -1; } -static void yaffs_VerifyObject(yaffs_Object *obj) +static int yaffs_alloc_chunk(struct yaffs_dev *dev, int use_reserver, + struct yaffs_block_info **block_ptr) { - yaffs_Device *dev; - - __u32 chunkMin; - __u32 chunkMax; - - __u32 chunkIdOk; - __u32 chunkIsLive; - - if(!obj) - return; - - dev = obj->myDev; - - if(yaffs_SkipVerification(dev)) - return; + int ret_val; + struct yaffs_block_info *bi; - /* Check sane object header chunk */ - - chunkMin = dev->internalStartBlock * dev->nChunksPerBlock; - chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1; + if (dev->alloc_block < 0) { + /* Get next block to allocate off */ + dev->alloc_block = yaffs_find_alloc_block(dev); + dev->alloc_page = 0; + } - chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax); - chunkIsLive = chunkIdOk && - yaffs_CheckChunkBit(dev, - obj->chunkId / dev->nChunksPerBlock, - obj->chunkId % dev->nChunksPerBlock); - if(!obj->fake && - (!chunkIdOk || !chunkIsLive)) { - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has chunkId %d %s %s"TENDSTR), - obj->objectId,obj->chunkId, - chunkIdOk ? "" : ",out of range", - chunkIsLive || !chunkIdOk ? "" : ",marked as deleted")); + if (!use_reserver && !yaffs_check_alloc_available(dev, 1)) { + /* No space unless we're allowed to use the reserve. */ + return -1; } - if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) { - yaffs_ExtendedTags tags; - yaffs_ObjectHeader *oh; - __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__); + if (dev->n_erased_blocks < dev->param.n_reserved_blocks + && dev->alloc_page == 0) + yaffs_trace(YAFFS_TRACE_ALLOCATE, "Allocating reserve"); - oh = (yaffs_ObjectHeader *)buffer; + /* Next page please.... */ + if (dev->alloc_block >= 0) { + bi = yaffs_get_block_info(dev, dev->alloc_block); - yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags); + 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); - yaffs_VerifyObjectHeader(obj,oh,&tags,1); + dev->alloc_page++; - yaffs_ReleaseTempBuffer(dev,buffer,__LINE__); - } + dev->n_free_chunks--; - /* Verify it has a parent */ - if(obj && !obj->fake && - (!obj->parent || obj->parent->myDev != dev)){ - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR), - obj->objectId,obj->parent)); - } + /* 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; + } - /* Verify parent is a directory */ - if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){ - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR), - obj->objectId,obj->parent->variantType)); - } + if (block_ptr) + *block_ptr = bi; - switch(obj->variantType){ - case YAFFS_OBJECT_TYPE_FILE: - yaffs_VerifyFile(obj); - break; - case YAFFS_OBJECT_TYPE_SYMLINK: - yaffs_VerifySymlink(obj); - break; - case YAFFS_OBJECT_TYPE_DIRECTORY: - yaffs_VerifyDirectory(obj); - break; - case YAFFS_OBJECT_TYPE_HARDLINK: - yaffs_VerifyHardLink(obj); - break; - case YAFFS_OBJECT_TYPE_SPECIAL: - yaffs_VerifySpecial(obj); - break; - case YAFFS_OBJECT_TYPE_UNKNOWN: - default: - T(YAFFS_TRACE_VERIFY, - (TSTR("Obj %d has illegaltype %d"TENDSTR), - obj->objectId,obj->variantType)); - break; + return ret_val; } + yaffs_trace(YAFFS_TRACE_ERROR, + "!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!"); + return -1; } -static void yaffs_VerifyObjects(yaffs_Device *dev) +static int yaffs_get_erased_chunks(struct yaffs_dev *dev) { - yaffs_Object *obj; - int i; - struct list_head *lh; - - if(yaffs_SkipVerification(dev)) - return; - - /* Iterate through the objects in each hash entry */ - - for(i = 0; i < YAFFS_NOBJECT_BUCKETS; i++){ - list_for_each(lh, &dev->objectBucket[i].list) { - if (lh) { - obj = list_entry(lh, yaffs_Object, hashLink); - yaffs_VerifyObject(obj); - } - } - } + 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); -/* - * Simple hash function. Needs to have a reasonable spread - */ + return n; -static Y_INLINE int yaffs_HashFunction(int n) -{ -/* XXX U-BOOT XXX */ - /*n = abs(n); */ - if (n < 0) - n = -n; - return (n % YAFFS_NOBJECT_BUCKETS); } /* - * Access functions to useful fake objects + * yaffs_skip_rest_of_block() skips over the rest of the allocation block + * if we don't want to write to it. */ - -yaffs_Object *yaffs_Root(yaffs_Device * dev) +void yaffs_skip_rest_of_block(struct yaffs_dev *dev) { - return dev->rootDir; -} + struct yaffs_block_info *bi; -yaffs_Object *yaffs_LostNFound(yaffs_Device * dev) -{ - return dev->lostNFoundDir; -} - - -/* - * Erased NAND checking functions - */ - -int yaffs_CheckFF(__u8 * buffer, int nBytes) -{ - /* Horrible, slow implementation */ - while (nBytes--) { - if (*buffer != 0xFF) - return 0; - buffer++; - } - return 1; -} - -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) -{ - - int retval = YAFFS_OK; - __u8 *data = yaffs_GetTempBuffer(dev, __LINE__); - yaffs_ExtendedTags tags; - - yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags); - - if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR) - retval = YAFFS_FAIL; - - - if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) { - T(YAFFS_TRACE_NANDACCESS, - (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND)); - retval = YAFFS_FAIL; + if (dev->alloc_block > 0) { + 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; + } } - - yaffs_ReleaseTempBuffer(dev, data, __LINE__); - - return retval; - } -static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, - const __u8 * data, - yaffs_ExtendedTags * tags, - int useReserve) +static int yaffs_write_new_chunk(struct yaffs_dev *dev, + const u8 *data, + struct yaffs_ext_tags *tags, int use_reserver) { int attempts = 0; - int writeOk = 0; + int write_ok = 0; int chunk; - yaffs_InvalidateCheckpoint(dev); + yaffs2_checkpt_invalidate(dev); do { - yaffs_BlockInfo *bi = 0; - int erasedOk = 0; + struct yaffs_block_info *bi = 0; + int erased_ok = 0; - chunk = yaffs_AllocateChunk(dev, useReserve, &bi); + chunk = yaffs_alloc_chunk(dev, use_reserver, &bi); if (chunk < 0) { /* no space */ break; @@ -897,7 +532,7 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, * * Check the first page we try to write in a block. * If the check passes then we don't need to check any - * more. If the check fails, we check again... + * more. If the check fails, we check again... * If the block has been erased, we don't need to check. * * However, if the block has been prioritised for gc, @@ -909,55 +544,63 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, * 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. */ - if (bi->gcPrioritise) { - yaffs_DeleteChunk(dev, chunk, 1, __LINE__); - /* try another chunk */ - continue; - } /* let's give it a try */ attempts++; -#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED - bi->skipErasedCheck = 0; -#endif - if (!bi->skipErasedCheck) { - erasedOk = yaffs_CheckChunkErased(dev, chunk); - if (erasedOk != YAFFS_OK) { - T(YAFFS_TRACE_ERROR, - (TSTR ("**>> yaffs chunk %d was not erased" - TENDSTR), chunk)); - - /* try another chunk */ + 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) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>> yaffs chunk %d was not erased", + 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; } - bi->skipErasedCheck = 1; } - writeOk = yaffs_WriteChunkWithTagsToNAND(dev, chunk, - data, tags); - if (writeOk != YAFFS_OK) { - yaffs_HandleWriteChunkError(dev, chunk, erasedOk); - /* try another chunk */ + 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_HandleWriteChunkOk(dev, chunk, data, tags); + yaffs_handle_chunk_wr_ok(dev, chunk, data, tags); - } while (writeOk != YAFFS_OK && - (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); + } while (write_ok != YAFFS_OK && + (yaffs_wr_attempts <= 0 || attempts <= yaffs_wr_attempts)); - if(!writeOk) + if (!write_ok) chunk = -1; if (attempts > 1) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs write required %d attempts" TENDSTR), - attempts)); - - dev->nRetriedWrites += (attempts - 1); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>> yaffs write required %d attempts", + attempts); + dev->n_retried_writes += (attempts - 1); } return chunk; @@ -967,109 +610,97 @@ static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, * Block retiring for handling a broken block. */ -static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND) +static void yaffs_retire_block(struct yaffs_dev *dev, int flash_block) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, flash_block); - yaffs_InvalidateCheckpoint(dev); + yaffs2_checkpt_invalidate(dev); - yaffs_MarkBlockBad(dev, blockInNAND); + yaffs2_clear_oldest_dirty_seq(dev, bi); - bi->blockState = YAFFS_BLOCK_STATE_DEAD; - bi->gcPrioritise = 0; - bi->needsRetiring = 0; + if (yaffs_mark_bad(dev, flash_block) != YAFFS_OK) { + if (yaffs_erase_block(dev, flash_block) != YAFFS_OK) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "yaffs: Failed to mark bad and erase block %d", + flash_block); + } else { + struct yaffs_ext_tags tags; + int chunk_id = + flash_block * dev->param.chunks_per_block; + + u8 *buffer = yaffs_get_temp_buffer(dev); + + memset(buffer, 0xff, dev->data_bytes_per_chunk); + memset(&tags, 0, sizeof(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) + yaffs_trace(YAFFS_TRACE_ALWAYS, + "yaffs: Failed to write bad block marker to block %d", + flash_block); + + yaffs_release_temp_buffer(dev, buffer); + } + } - dev->nRetiredBlocks++; -} + bi->block_state = YAFFS_BLOCK_STATE_DEAD; + bi->gc_prioritise = 0; + bi->needs_retiring = 0; -/* - * Functions for robustisizing TODO - * - */ - -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, - const yaffs_ExtendedTags * tags) -{ + dev->n_retired_blocks++; } -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND, - const yaffs_ExtendedTags * tags) -{ -} +/*---------------- Name handling functions ------------*/ -void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi) +static u16 yaffs_calc_name_sum(const YCHAR *name) { - if(!bi->gcPrioritise){ - bi->gcPrioritise = 1; - dev->hasPendingPrioritisedGCs = 1; - bi->chunkErrorStrikes ++; + u16 sum = 0; + u16 i = 1; - if(bi->chunkErrorStrikes > 3){ - bi->needsRetiring = 1; /* Too many stikes, so retire this */ - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR))); + if (!name) + return 0; - } + while ((*name) && i < (YAFFS_MAX_NAME_LENGTH / 2)) { + /* 0x1f mask is case insensitive */ + sum += ((*name) & 0x1f) * i; + i++; + name++; } + return sum; } -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk) +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR * name) { - - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND); - - yaffs_HandleChunkError(dev,bi); - - - if(erasedOk ) { - /* Was an actual write failure, so mark the block for retirement */ - bi->needsRetiring = 1; - T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND)); - - - } - - /* Delete the chunk */ - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); + memset(obj->short_name, 0, sizeof(obj->short_name)); + 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'); + obj->sum = yaffs_calc_name_sum(name); } - -/*---------------- Name handling functions ------------*/ - -static __u16 yaffs_CalcNameSum(const YCHAR * name) +void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, + const struct yaffs_obj_hdr *oh) { - __u16 sum = 0; - __u16 i = 1; - - YUCHAR *bname = (YUCHAR *) name; - if (bname) { - while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) { - -#ifdef CONFIG_YAFFS_CASE_INSENSITIVE - sum += yaffs_toupper(*bname) * i; +#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 - sum += (*bname) * i; + yaffs_set_obj_name(obj, oh->name); #endif - i++; - bname++; - } - } - return sum; } -static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name) +loff_t yaffs_max_file_size(struct yaffs_dev *dev) { -#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH) { - yaffs_strcpy(obj->shortName, name); - } else { - obj->shortName[0] = _Y('\0'); - } -#endif - obj->sum = yaffs_CalcNameSum(name); + return ((loff_t) YAFFS_MAX_CHUNK_ID) * dev->data_bytes_per_chunk; } /*-------------------- TNODES ------------------- @@ -1079,381 +710,235 @@ static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name) * in the tnode. */ -/* yaffs_CreateTnodes creates a bunch more tnodes and - * adds them to the tnode free list. - * Don't use this function directly - */ - -static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes) +struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev) { - int i; - int tnodeSize; - yaffs_Tnode *newTnodes; - __u8 *mem; - yaffs_Tnode *curr; - yaffs_Tnode *next; - yaffs_TnodeList *tnl; - - if (nTnodes < 1) - return YAFFS_OK; - - /* Calculate the tnode size in bytes for variable width tnode support. - * Must be a multiple of 32-bits */ - tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - /* make these things */ - - newTnodes = YMALLOC(nTnodes * tnodeSize); - mem = (__u8 *)newTnodes; - - if (!newTnodes) { - T(YAFFS_TRACE_ERROR, - (TSTR("yaffs: Could not allocate Tnodes" TENDSTR))); - return YAFFS_FAIL; - } - - /* Hook them into the free list */ -#if 0 - for (i = 0; i < nTnodes - 1; i++) { - newTnodes[i].internal[0] = &newTnodes[i + 1]; -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - newTnodes[i].internal[YAFFS_NTNODES_INTERNAL] = (void *)1; -#endif - } - - newTnodes[nTnodes - 1].internal[0] = dev->freeTnodes; -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - newTnodes[nTnodes - 1].internal[YAFFS_NTNODES_INTERNAL] = (void *)1; -#endif - dev->freeTnodes = newTnodes; -#else - /* New hookup for wide tnodes */ - for(i = 0; i < nTnodes -1; i++) { - curr = (yaffs_Tnode *) &mem[i * tnodeSize]; - next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize]; - curr->internal[0] = next; - } - - curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize]; - curr->internal[0] = dev->freeTnodes; - dev->freeTnodes = (yaffs_Tnode *)mem; - -#endif - - - dev->nFreeTnodes += nTnodes; - dev->nTnodesCreated += nTnodes; - - /* 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)); - 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 = dev->allocatedTnodeList; - dev->allocatedTnodeList = tnl; - } - - T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR))); - - return YAFFS_OK; -} - -/* GetTnode gets us a clean tnode. Tries to make allocate more if we run out */ - -static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev) -{ - yaffs_Tnode *tn = NULL; - - /* If there are none left make more */ - if (!dev->freeTnodes) { - yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES); - } + struct yaffs_tnode *tn = yaffs_alloc_raw_tnode(dev); - if (dev->freeTnodes) { - tn = dev->freeTnodes; -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - if (tn->internal[YAFFS_NTNODES_INTERNAL] != (void *)1) { - /* Hoosterman, this thing looks like it isn't in the list */ - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: Tnode list bug 1" TENDSTR))); - } -#endif - dev->freeTnodes = dev->freeTnodes->internal[0]; - dev->nFreeTnodes--; + if (tn) { + memset(tn, 0, dev->tnode_size); + dev->n_tnodes++; } - return tn; -} - -static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev) -{ - yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev); - - if(tn) - memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8); + 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_FreeTnode(yaffs_Device * dev, yaffs_Tnode * tn) +static void yaffs_free_tnode(struct yaffs_dev *dev, struct yaffs_tnode *tn) { - if (tn) { -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - if (tn->internal[YAFFS_NTNODES_INTERNAL] != 0) { - /* Hoosterman, this thing looks like it is already in the list */ - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: Tnode list bug 2" TENDSTR))); - } - tn->internal[YAFFS_NTNODES_INTERNAL] = (void *)1; -#endif - tn->internal[0] = dev->freeTnodes; - dev->freeTnodes = tn; - dev->nFreeTnodes++; - } + yaffs_free_raw_tnode(dev, tn); + dev->n_tnodes--; + dev->checkpoint_blocks_required = 0; /* force recalculation */ } -static void yaffs_DeinitialiseTnodes(yaffs_Device * dev) +static void yaffs_deinit_tnodes_and_objs(struct yaffs_dev *dev) { - /* Free the list of allocated tnodes */ - yaffs_TnodeList *tmp; - - while (dev->allocatedTnodeList) { - tmp = dev->allocatedTnodeList->next; - - YFREE(dev->allocatedTnodeList->tnodes); - YFREE(dev->allocatedTnodeList); - dev->allocatedTnodeList = tmp; - - } - - dev->freeTnodes = NULL; - dev->nFreeTnodes = 0; + yaffs_deinit_raw_tnodes_and_objs(dev); + dev->n_obj = 0; + dev->n_tnodes = 0; } -static void yaffs_InitialiseTnodes(yaffs_Device * dev) +void yaffs_load_tnode_0(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos, unsigned val) { - dev->allocatedTnodeList = NULL; - dev->freeTnodes = NULL; - dev->nFreeTnodes = 0; - dev->nTnodesCreated = 0; + 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); -void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsigned val) -{ - __u32 *map = (__u32 *)tn; - __u32 bitInMap; - __u32 bitInWord; - __u32 wordInMap; - __u32 mask; - - pos &= YAFFS_TNODES_LEVEL0_MASK; - val >>= dev->chunkGroupBits; - - bitInMap = pos * dev->tnodeWidth; - wordInMap = bitInMap /32; - bitInWord = bitInMap & (32 -1); + mask = dev->tnode_mask << bit_in_word; - mask = dev->tnodeMask << bitInWord; + map[word_in_map] &= ~mask; + map[word_in_map] |= (mask & (val << bit_in_word)); - map[wordInMap] &= ~mask; - map[wordInMap] |= (mask & (val << bitInWord)); - - if(dev->tnodeWidth > (32-bitInWord)) { - bitInWord = (32 - bitInWord); - wordInMap++;; - mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord); - map[wordInMap] &= ~mask; - map[wordInMap] |= (mask & (val >> bitInWord)); - } + if (dev->tnode_width > (32 - bit_in_word)) { + bit_in_word = (32 - bit_in_word); + word_in_map++; + mask = + dev->tnode_mask >> bit_in_word; + map[word_in_map] &= ~mask; + map[word_in_map] |= (mask & (val >> bit_in_word)); + } } -static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos) +u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos) { - __u32 *map = (__u32 *)tn; - __u32 bitInMap; - __u32 bitInWord; - __u32 wordInMap; - __u32 val; + u32 *map = (u32 *) tn; + u32 bit_in_map; + u32 bit_in_word; + u32 word_in_map; + u32 val; - pos &= YAFFS_TNODES_LEVEL0_MASK; + pos &= YAFFS_TNODES_LEVEL0_MASK; - bitInMap = pos * dev->tnodeWidth; - wordInMap = bitInMap /32; - bitInWord = bitInMap & (32 -1); + bit_in_map = pos * dev->tnode_width; + word_in_map = bit_in_map / 32; + bit_in_word = bit_in_map & (32 - 1); - val = map[wordInMap] >> bitInWord; + val = map[word_in_map] >> bit_in_word; - if(dev->tnodeWidth > (32-bitInWord)) { - bitInWord = (32 - bitInWord); - wordInMap++;; - val |= (map[wordInMap] << bitInWord); - } + 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->tnodeMask; - val <<= dev->chunkGroupBits; + val &= dev->tnode_mask; + val <<= dev->chunk_grp_bits; - return val; + 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 topLevel + * 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. */ -static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev, - yaffs_FileStructure * fStruct, - __u32 chunkId) +struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id) { + struct yaffs_tnode *tn = file_struct->top; + u32 i; + int required_depth; + int level = file_struct->top_level; - yaffs_Tnode *tn = fStruct->top; - __u32 i; - int requiredTallness; - int level = fStruct->topLevel; + dev = dev; /* Check sane level and chunk Id */ - if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) { + if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) return NULL; - } - if (chunkId > YAFFS_MAX_CHUNK_ID) { + if (chunk_id > YAFFS_MAX_CHUNK_ID) return NULL; - } - /* First check we're tall enough (ie enough topLevel) */ + /* First check we're tall enough (ie enough top_level) */ - i = chunkId >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; + i = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; + required_depth = 0; while (i) { i >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; + required_depth++; } - if (requiredTallness > fStruct->topLevel) { - /* Not tall enough, so we can't find it, return NULL. */ - return NULL; - } + 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[(chunkId >> - ( YAFFS_TNODES_LEVEL0_BITS + - (level - 1) * - YAFFS_TNODES_INTERNAL_BITS) - ) & - YAFFS_TNODES_INTERNAL_MASK]; + 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. +/* add_find_tnode_0 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. + * If the tn argument is NULL, then a fresh tnode will be added otherwise the + * specified tn will be plugged into the ttree. */ -static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev, - yaffs_FileStructure * fStruct, - __u32 chunkId, - yaffs_Tnode *passedTn) +struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn) { - - int requiredTallness; + int required_depth; int i; int l; - yaffs_Tnode *tn; - - __u32 x; - + struct yaffs_tnode *tn; + u32 x; /* Check sane level and page Id */ - if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) { + if (file_struct->top_level < 0 || + file_struct->top_level > YAFFS_TNODES_MAX_LEVEL) return NULL; - } - if (chunkId > YAFFS_MAX_CHUNK_ID) { + if (chunk_id > YAFFS_MAX_CHUNK_ID) return NULL; - } - /* First check we're tall enough (ie enough topLevel) */ + /* First check we're tall enough (ie enough top_level) */ - x = chunkId >> YAFFS_TNODES_LEVEL0_BITS; - requiredTallness = 0; + x = chunk_id >> YAFFS_TNODES_LEVEL0_BITS; + required_depth = 0; while (x) { x >>= YAFFS_TNODES_INTERNAL_BITS; - requiredTallness++; + 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++) { - if (requiredTallness > fStruct->topLevel) { - /* Not tall enough,gotta make the tree taller */ - for (i = fStruct->topLevel; i < requiredTallness; i++) { - - tn = yaffs_GetTnode(dev); + tn = yaffs_get_tnode(dev); if (tn) { - tn->internal[0] = fStruct->top; - fStruct->top = 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))); + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs: no more tnodes"); + return NULL; } } - - fStruct->topLevel = requiredTallness; } /* Traverse down to level 0, adding anything we need */ - l = fStruct->topLevel; - tn = fStruct->top; + l = file_struct->top_level; + tn = file_struct->top; - if(l > 0) { + if (l > 0) { while (l > 0 && tn) { - x = (chunkId >> - ( YAFFS_TNODES_LEVEL0_BITS + + x = (chunk_id >> + (YAFFS_TNODES_LEVEL0_BITS + (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) & YAFFS_TNODES_INTERNAL_MASK; - - if((l>1) && !tn->internal[x]){ + if ((l > 1) && !tn->internal[x]) { /* Add missing non-level-zero tnode */ - tn->internal[x] = yaffs_GetTnode(dev); - - } else if(l == 1) { + 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 (passedTn) { - /* If we already have one, then release it.*/ - if(tn->internal[x]) - yaffs_FreeTnode(dev,tn->internal[x]); - tn->internal[x] = passedTn; - - } else if(!tn->internal[x]) { + if (passed_tn) { + /* If we already have one, 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_GetTnode(dev); + tn->internal[x] = yaffs_get_tnode(dev); + if (!tn->internal[x]) + return NULL; } } @@ -1462,2979 +947,2479 @@ static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev, } } else { /* top is level 0 */ - if(passedTn) { - memcpy(tn,passedTn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8); - yaffs_FreeTnode(dev,passedTn); + 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_FindChunkInGroup(yaffs_Device * dev, int theChunk, - yaffs_ExtendedTags * tags, int objectId, - int chunkInInode) +static int yaffs_tags_match(const struct yaffs_ext_tags *tags, int obj_id, + int chunk_obj) { - int j; + return (tags->chunk_id == chunk_obj && + tags->obj_id == obj_id && + !tags->is_deleted) ? 1 : 0; - for (j = 0; theChunk && j < dev->chunkGroupSize; j++) { - if (yaffs_CheckChunkBit - (dev, theChunk / dev->nChunksPerBlock, - theChunk % dev->nChunksPerBlock)) { - yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL, - tags); - if (yaffs_TagsMatch(tags, objectId, chunkInInode)) { - /* found it; */ - return theChunk; +} +static int yaffs_find_chunk_in_group(struct yaffs_dev *dev, int the_chunk, + struct yaffs_ext_tags *tags, int obj_id, + int inode_chunk) +{ + int j; + + for (j = 0; the_chunk && j < dev->chunk_grp_size; j++) { + if (yaffs_check_chunk_bit + (dev, the_chunk / dev->param.chunks_per_block, + the_chunk % dev->param.chunks_per_block)) { + + if (dev->chunk_grp_size == 1) + 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; + } } } - theChunk++; + the_chunk++; } return -1; } -static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk) +static int yaffs_find_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags) { + /*Get the Tnode, then get the level 0 offset chunk offset */ + struct yaffs_tnode *tn; + int the_chunk = -1; + struct yaffs_ext_tags local_tags; + int ret_val = -1; + struct yaffs_dev *dev = in->my_dev; - yaffs_BlockInfo *theBlock; - - T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk)); - - theBlock = yaffs_GetBlockInfo(dev, chunk / dev->nChunksPerBlock); - if (theBlock) { - theBlock->softDeletions++; - dev->nFreeChunks++; + if (!tags) { + /* Passed a NULL, so use our own tags space */ + tags = &local_tags; } -} - -/* 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_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, - __u32 level, int chunkOffset) -{ - int i; - int theChunk; - int allDone = 1; - yaffs_Device *dev = in->myDev; - - if (tn) { - if (level > 0) { - - for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0; - i--) { - if (tn->internal[i]) { - allDone = - yaffs_SoftDeleteWorker(in, - tn-> - internal[i], - level - 1, - (chunkOffset - << - YAFFS_TNODES_INTERNAL_BITS) - + i); - if (allDone) { - yaffs_FreeTnode(dev, - tn-> - internal[i]); - tn->internal[i] = NULL; - } else { - /* Hoosterman... how could this happen? */ - } - } - } - return (allDone) ? 1 : 0; - } else if (level == 0) { - - for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) { - theChunk = yaffs_GetChunkGroupBase(dev,tn,i); - if (theChunk) { - /* 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_SoftDeleteChunk(dev, theChunk); - yaffs_PutLevel0Tnode(dev,tn,i,0); - } - - } - return 1; - - } - } + tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); - return 1; + if (!tn) + return ret_val; -} + the_chunk = yaffs_get_group_base(dev, tn, inode_chunk); -static void yaffs_SoftDeleteFile(yaffs_Object * obj) -{ - if (obj->deleted && - obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) { - if (obj->nDataChunks <= 0) { - /* Empty file with no duplicate object headers, just delete it immediately */ - yaffs_FreeTnode(obj->myDev, - obj->variant.fileVariant.top); - obj->variant.fileVariant.top = NULL; - T(YAFFS_TRACE_TRACING, - (TSTR("yaffs: Deleting empty file %d" TENDSTR), - obj->objectId)); - yaffs_DoGenericObjectDeletion(obj); - } else { - yaffs_SoftDeleteWorker(obj, - obj->variant.fileVariant.top, - obj->variant.fileVariant. - topLevel, 0); - obj->softDeleted = 1; - } - } + ret_val = yaffs_find_chunk_in_group(dev, the_chunk, tags, in->obj_id, + inode_chunk); + return ret_val; } -/* 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. - */ - -static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device * dev, yaffs_Tnode * tn, - __u32 level, int del0) +static int yaffs_find_del_file_chunk(struct yaffs_obj *in, int inode_chunk, + struct yaffs_ext_tags *tags) { - int i; - int hasData; - - if (tn) { - hasData = 0; + /* Get the Tnode, then get the level 0 offset chunk offset */ + struct yaffs_tnode *tn; + int the_chunk = -1; + struct yaffs_ext_tags local_tags; + struct yaffs_dev *dev = in->my_dev; + int ret_val = -1; - for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) { - if (tn->internal[i] && level > 0) { - tn->internal[i] = - yaffs_PruneWorker(dev, tn->internal[i], - level - 1, - (i == 0) ? del0 : 1); - } + if (!tags) { + /* Passed a NULL, so use our own tags space */ + tags = &local_tags; + } - if (tn->internal[i]) { - hasData++; - } - } + tn = yaffs_find_tnode_0(dev, &in->variant.file_variant, inode_chunk); - if (hasData == 0 && del0) { - /* Free and return NULL */ + if (!tn) + return ret_val; - yaffs_FreeTnode(dev, tn); - tn = NULL; - } + 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 tn; + /* Delete the entry in the filestructure (if found) */ + if (ret_val != -1) + yaffs_load_tnode_0(dev, tn, inode_chunk, 0); + return ret_val; } -static int yaffs_PruneFileStructure(yaffs_Device * dev, - yaffs_FileStructure * fStruct) +int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + int nand_chunk, int in_scan) { - int i; - int hasData; - int done = 0; - yaffs_Tnode *tn; + /* 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. + */ - if (fStruct->topLevel > 0) { - fStruct->top = - yaffs_PruneWorker(dev, fStruct->top, fStruct->topLevel, 0); + struct yaffs_tnode *tn; + struct yaffs_dev *dev = in->my_dev; + int existing_cunk; + struct yaffs_ext_tags existing_tags; + struct yaffs_ext_tags new_tags; + unsigned existing_serial, new_serial; - /* 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) + 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! */ - - while (fStruct->topLevel && !done) { - tn = fStruct->top; - - hasData = 0; - for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) { - if (tn->internal[i]) { - hasData++; - } - } - - if (!hasData) { - fStruct->top = tn->internal[0]; - fStruct->topLevel--; - yaffs_FreeTnode(dev, tn); - } else { - done = 1; - } + if (!in_scan) { + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy:attempt to put data chunk into a non-file" + ); + BUG(); } - } - - return YAFFS_OK; -} - -/*-------------------- End of File Structure functions.-------------------*/ -/* yaffs_CreateFreeObjects creates a bunch more objects and - * adds them to the object free list. - */ -static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects) -{ - int i; - yaffs_Object *newObjects; - yaffs_ObjectList *list; - - if (nObjects < 1) + yaffs_chunk_del(dev, nand_chunk, 1, __LINE__); return YAFFS_OK; - - /* make these things */ - newObjects = YMALLOC(nObjects * sizeof(yaffs_Object)); - list = YMALLOC(sizeof(yaffs_ObjectList)); - - if (!newObjects || !list) { - if(newObjects) - YFREE(newObjects); - if(list) - YFREE(list); - 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 < nObjects - 1; i++) { - newObjects[i].siblings.next = - (struct list_head *)(&newObjects[i + 1]); } - newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects; - dev->freeObjects = newObjects; - dev->nFreeObjects += nObjects; - dev->nObjectsCreated += nObjects; - - /* Now add this bunch of Objects to a list for freeing up. */ - - list->objects = newObjects; - list->next = dev->allocatedObjectList; - dev->allocatedObjectList = list; - - return YAFFS_OK; -} - - -/* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */ -static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device * dev) -{ - yaffs_Object *tn = NULL; - - /* If there are none left make more */ - if (!dev->freeObjects) { - yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS); - } - - if (dev->freeObjects) { - tn = dev->freeObjects; - dev->freeObjects = - (yaffs_Object *) (dev->freeObjects->siblings.next); - dev->nFreeObjects--; + tn = yaffs_add_find_tnode_0(dev, + &in->variant.file_variant, + inode_chunk, NULL); + if (!tn) + return YAFFS_FAIL; - /* Now sweeten it up... */ + if (!nand_chunk) + /* Dummy insert, bail now */ + return YAFFS_OK; - memset(tn, 0, sizeof(yaffs_Object)); - tn->myDev = dev; - tn->chunkId = -1; - tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN; - INIT_LIST_HEAD(&(tn->hardLinks)); - INIT_LIST_HEAD(&(tn->hashLink)); - INIT_LIST_HEAD(&tn->siblings); + existing_cunk = yaffs_get_group_base(dev, tn, inode_chunk); - /* Add it to the lost and found directory. - * NB Can't put root or lostNFound in lostNFound so - * check if lostNFound exists first + 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 + * 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 (dev->lostNFoundDir) { - yaffs_AddObjectToDirectory(dev->lostNFoundDir, tn); - } - } - return tn; -} - -static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device * dev, int number, - __u32 mode) -{ + 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. + * YAFFS1: Get both sets of tags and compare serial + * numbers. + */ - yaffs_Object *obj = - yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); - if (obj) { - obj->fake = 1; /* it is fake so it has no NAND presence... */ - obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */ - obj->unlinkAllowed = 0; /* ... or unlink it */ - obj->deleted = 0; - obj->unlinked = 0; - obj->yst_mode = mode; - obj->myDev = dev; - obj->chunkId = 0; /* Not a valid chunk. */ - } + if (in_scan > 0) { + /* Only do this for forward scanning */ + yaffs_rd_chunk_tags_nand(dev, + nand_chunk, + NULL, &new_tags); - return obj; + /* 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? */ -static void yaffs_UnhashObject(yaffs_Object * tn) -{ - int bucket; - yaffs_Device *dev = tn->myDev; + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy: existing chunk < 0 in scan" + ); - /* If it is still linked into the bucket list, free from the list */ - if (!list_empty(&tn->hashLink)) { - list_del_init(&tn->hashLink); - bucket = yaffs_HashFunction(tn->objectId); - dev->objectBucket[bucket].count--; - } + } -} + /* NB The deleted flags should be false, otherwise + * the chunks will not be loaded during a scan + */ -/* FreeObject frees up a Object and puts it back on the free list */ -static void yaffs_FreeObject(yaffs_Object * tn) -{ + if (in_scan > 0) { + new_serial = new_tags.serial_number; + existing_serial = existing_tags.serial_number; + } - yaffs_Device *dev = tn->myDev; + 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 + * 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; + } + } -/* XXX U-BOOT XXX */ -#if 0 -#ifdef __KERNEL__ - if (tn->myInode) { - /* We're still hooked up to a cached inode. - * Don't delete now, but mark for later deletion - */ - tn->deferedFree = 1; - return; } -#endif -#endif - yaffs_UnhashObject(tn); - /* Link into the free list. */ - tn->siblings.next = (struct list_head *)(dev->freeObjects); - dev->freeObjects = tn; - dev->nFreeObjects++; -} + if (existing_cunk == 0) + in->n_data_chunks++; -/* XXX U-BOOT XXX */ -#if 0 -#ifdef __KERNEL__ + yaffs_load_tnode_0(dev, tn, inode_chunk, nand_chunk); -void yaffs_HandleDeferedFree(yaffs_Object * obj) -{ - if (obj->deferedFree) { - yaffs_FreeObject(obj); - } + return YAFFS_OK; } -#endif -#endif - -static void yaffs_DeinitialiseObjects(yaffs_Device * dev) +static void yaffs_soft_del_chunk(struct yaffs_dev *dev, int chunk) { - /* Free the list of allocated Objects */ + struct yaffs_block_info *the_block; + unsigned block_no; - yaffs_ObjectList *tmp; + yaffs_trace(YAFFS_TRACE_DELETION, "soft delete chunk %d", chunk); - while (dev->allocatedObjectList) { - tmp = dev->allocatedObjectList->next; - YFREE(dev->allocatedObjectList->objects); - YFREE(dev->allocatedObjectList); - - dev->allocatedObjectList = tmp; + 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); } - - dev->freeObjects = NULL; - dev->nFreeObjects = 0; } -static void yaffs_InitialiseObjects(yaffs_Device * dev) -{ - int i; - - dev->allocatedObjectList = NULL; - dev->freeObjects = NULL; - dev->nFreeObjects = 0; - - for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { - INIT_LIST_HEAD(&dev->objectBucket[i].list); - dev->objectBucket[i].count = 0; - } - -} +/* 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_FindNiceObjectBucket(yaffs_Device * dev) +static int yaffs_soft_del_worker(struct yaffs_obj *in, struct yaffs_tnode *tn, + u32 level, int chunk_offset) { - static int x = 0; int i; - int l = 999; - int lowest = 999999; + int the_chunk; + int all_done = 1; + struct yaffs_dev *dev = in->my_dev; - /* First let's see if we can find one that's empty. */ + if (!tn) + return 1; - for (i = 0; i < 10 && lowest > 0; i++) { - x++; - x %= YAFFS_NOBJECT_BUCKETS; - if (dev->objectBucket[x].count < lowest) { - lowest = dev->objectBucket[x].count; - l = x; + 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 { + /* Can this happen? */ + } + } } - + return (all_done) ? 1 : 0; } - /* If we didn't find an empty list, then try - * looking a bit further for a short one - */ - - for (i = 0; i < 10 && lowest > 3; i++) { - x++; - x %= YAFFS_NOBJECT_BUCKETS; - if (dev->objectBucket[x].count < lowest) { - lowest = dev->objectBucket[x].count; - l = x; + /* level 0 */ + for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) { + the_chunk = yaffs_get_group_base(dev, tn, i); + if (the_chunk) { + yaffs_soft_del_chunk(dev, the_chunk); + yaffs_load_tnode_0(dev, tn, i, 0); } - } - - return l; + return 1; } -static int yaffs_CreateNewObjectNumber(yaffs_Device * dev) +static void yaffs_remove_obj_from_dir(struct yaffs_obj *obj) { - int bucket = yaffs_FindNiceObjectBucket(dev); + struct yaffs_dev *dev = obj->my_dev; + struct yaffs_obj *parent; - /* Now find an object value that has not already been taken - * by scanning the list. - */ + yaffs_verify_obj_in_dir(obj); + parent = obj->parent; - int found = 0; - struct list_head *i; + yaffs_verify_dir(parent); - __u32 n = (__u32) bucket; + if (dev && dev->param.remove_obj_fn) + dev->param.remove_obj_fn(obj); - /* yaffs_CheckObjectHashSanity(); */ - - while (!found) { - found = 1; - n += YAFFS_NOBJECT_BUCKETS; - if (1 || dev->objectBucket[bucket].count > 0) { - list_for_each(i, &dev->objectBucket[bucket].list) { - /* If there is already one in the list */ - if (i - && list_entry(i, yaffs_Object, - hashLink)->objectId == n) { - found = 0; - } - } - } - } - - - return n; -} - -static void yaffs_HashObject(yaffs_Object * in) -{ - int bucket = yaffs_HashFunction(in->objectId); - yaffs_Device *dev = in->myDev; - - list_add(&in->hashLink, &dev->objectBucket[bucket].list); - dev->objectBucket[bucket].count++; + list_del_init(&obj->siblings); + obj->parent = NULL; + yaffs_verify_dir(parent); } -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number) +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj) { - int bucket = yaffs_HashFunction(number); - struct list_head *i; - yaffs_Object *in; - - list_for_each(i, &dev->objectBucket[bucket].list) { - /* Look if it is in the list */ - if (i) { - in = list_entry(i, yaffs_Object, hashLink); - if (in->objectId == number) { -/* XXX U-BOOT XXX */ -#if 0 -#ifdef __KERNEL__ - /* Don't tell the VFS about this one if it is defered free */ - if (in->deferedFree) - return NULL; -#endif -#endif - return in; - } - } + if (!directory) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "tragedy: Trying to add an object to a null pointer directory" + ); + BUG(); + return; } - - return NULL; -} - -yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number, - yaffs_ObjectType type) -{ - - yaffs_Object *theObject; - yaffs_Tnode *tn = NULL; - - if (number < 0) { - number = yaffs_CreateNewObjectNumber(dev); + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "tragedy: Trying to add an object to a non-directory" + ); + BUG(); } - theObject = yaffs_AllocateEmptyObject(dev); - if(!theObject) - return NULL; - - if(type == YAFFS_OBJECT_TYPE_FILE){ - tn = yaffs_GetTnode(dev); - if(!tn){ - yaffs_FreeObject(theObject); - return NULL; - } + if (obj->siblings.prev == NULL) { + /* Not initialised */ + BUG(); } + yaffs_verify_dir(directory); + yaffs_remove_obj_from_dir(obj); - if (theObject) { - theObject->fake = 0; - theObject->renameAllowed = 1; - theObject->unlinkAllowed = 1; - theObject->objectId = number; - yaffs_HashObject(theObject); - theObject->variantType = type; -#ifdef CONFIG_YAFFS_WINCE - yfsd_WinFileTimeNow(theObject->win_atime); - theObject->win_ctime[0] = theObject->win_mtime[0] = - theObject->win_atime[0]; - theObject->win_ctime[1] = theObject->win_mtime[1] = - theObject->win_atime[1]; - -#else + /* Now add it */ + list_add(&obj->siblings, &directory->variant.dir_variant.children); + obj->parent = directory; - theObject->yst_atime = theObject->yst_mtime = - theObject->yst_ctime = Y_CURRENT_TIME; -#endif - switch (type) { - case YAFFS_OBJECT_TYPE_FILE: - theObject->variant.fileVariant.fileSize = 0; - theObject->variant.fileVariant.scannedFileSize = 0; - theObject->variant.fileVariant.shrinkSize = 0xFFFFFFFF; /* max __u32 */ - theObject->variant.fileVariant.topLevel = 0; - theObject->variant.fileVariant.top = tn; - break; - case YAFFS_OBJECT_TYPE_DIRECTORY: - INIT_LIST_HEAD(&theObject->variant.directoryVariant. - children); - 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; - } + if (directory == obj->my_dev->unlinked_dir + || directory == obj->my_dev->del_dir) { + obj->unlinked = 1; + obj->my_dev->n_unlinked_files++; + obj->rename_allowed = 0; } - return theObject; + yaffs_verify_dir(directory); + yaffs_verify_obj_in_dir(obj); } -static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev, - int number, - yaffs_ObjectType type) +static int yaffs_change_obj_name(struct yaffs_obj *obj, + struct yaffs_obj *new_dir, + const YCHAR *new_name, int force, int shadows) { - yaffs_Object *theObject = NULL; + int unlink_op; + int del_op; + struct yaffs_obj *existing_target; - if (number > 0) { - theObject = yaffs_FindObjectByNumber(dev, number); - } + if (new_dir == NULL) + new_dir = obj->parent; /* use the old directory */ - if (!theObject) { - theObject = yaffs_CreateNewObject(dev, number, type); + if (new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "tragedy: yaffs_change_obj_name: new_dir is not a directory" + ); + BUG(); } - return theObject; + unlink_op = (new_dir == obj->my_dev->unlinked_dir); + 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 OK. + * else only proceed if the new name does not exist and 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) + return YAFFS_FAIL; -static YCHAR *yaffs_CloneString(const YCHAR * str) -{ - YCHAR *newStr = NULL; + yaffs_set_obj_name(obj, new_name); + obj->dirty = 1; + yaffs_add_obj_to_dir(new_dir, obj); - if (str && *str) { - newStr = YMALLOC((yaffs_strlen(str) + 1) * sizeof(YCHAR)); - if(newStr) - yaffs_strcpy(newStr, str); - } + if (unlink_op) + obj->unlinked = 1; - return newStr; + /* If it is a deletion then we mark it as a shrink for gc */ + if (yaffs_update_oh(obj, new_name, 0, del_op, shadows, NULL) >= 0) + return YAFFS_OK; + return YAFFS_FAIL; } -/* - * Mknod (create) a new object. - * equivalentObject only has meaning for a hard link; - * aliasString only has meaning for a sumlink. - * rdev only has meaning for devices (a subset of special objects) +/*------------------------ Short Operations Cache ------------------------------ + * In many situations where there is no high level buffering a lot of + * reads might be short sequential reads, and a lot of writes may be short + * sequential writes. eg. scanning/writing a jpeg file. + * In these cases, a short read/write cache can provide a huge perfomance + * benefit with dumb-as-a-rock code. + * In Linux, the page cache provides read buffering and the short op cache + * provides write buffering. + * + * There are a small number (~10) of cache chunks per device so that we don't + * need a very intelligent search. */ -static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type, - yaffs_Object * parent, - const YCHAR * name, - __u32 mode, - __u32 uid, - __u32 gid, - yaffs_Object * equivalentObject, - const YCHAR * aliasString, __u32 rdev) +static int yaffs_obj_cache_dirty(struct yaffs_obj *obj) { - yaffs_Object *in; - YCHAR *str = NULL; - - yaffs_Device *dev = parent->myDev; - - /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/ - if (yaffs_FindObjectByName(parent, name)) { - return NULL; - } - - in = yaffs_CreateNewObject(dev, -1, type); + struct yaffs_dev *dev = obj->my_dev; + int i; + struct yaffs_cache *cache; + int n_caches = obj->my_dev->param.n_caches; - if(type == YAFFS_OBJECT_TYPE_SYMLINK){ - str = yaffs_CloneString(aliasString); - if(!str){ - yaffs_FreeObject(in); - return NULL; - } + for (i = 0; i < n_caches; i++) { + cache = &dev->cache[i]; + if (cache->object == obj && cache->dirty) + return 1; } + return 0; +} +static void yaffs_flush_file_cache(struct yaffs_obj *obj) +{ + struct yaffs_dev *dev = obj->my_dev; + int lowest = -99; /* Stop compiler whining. */ + int i; + struct yaffs_cache *cache; + int chunk_written = 0; + int n_caches = obj->my_dev->param.n_caches; - if (in) { - in->chunkId = -1; - in->valid = 1; - in->variantType = type; - - in->yst_mode = mode; - -#ifdef CONFIG_YAFFS_WINCE - yfsd_WinFileTimeNow(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->nDataChunks = 0; - - yaffs_SetObjectName(in, name); - in->dirty = 1; - - yaffs_AddObjectToDirectory(parent, in); - - in->myDev = parent->myDev; - - switch (type) { - case YAFFS_OBJECT_TYPE_SYMLINK: - in->variant.symLinkVariant.alias = str; - break; - case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardLinkVariant.equivalentObject = - equivalentObject; - in->variant.hardLinkVariant.equivalentObjectId = - equivalentObject->objectId; - list_add(&in->hardLinks, &equivalentObject->hardLinks); - 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 (n_caches < 1) + return; + do { + cache = NULL; + + /* Find the lowest dirty chunk for this object */ + for (i = 0; i < n_caches; i++) { + if (dev->cache[i].object == obj && + dev->cache[i].dirty) { + if (!cache || + dev->cache[i].chunk_id < lowest) { + cache = &dev->cache[i]; + lowest = cache->chunk_id; + } + } } - if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) { - /* Could not create the object header, fail the creation */ - yaffs_DestroyObject(in); - in = NULL; + if (cache && !cache->locked) { + /* Write it out and free it up */ + chunk_written = + yaffs_wr_data_obj(cache->object, + cache->chunk_id, + cache->data, + cache->n_bytes, 1); + cache->dirty = 0; + cache->object = NULL; } + } while (cache && chunk_written > 0); - } - - return in; + if (cache) + /* Hoosterman, disk full while writing cache out. */ + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy: no space during cache write"); } -yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid) -{ - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, - uid, gid, NULL, NULL, 0); -} +/*yaffs_flush_whole_cache(dev) + * + * + */ -yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid) +void yaffs_flush_whole_cache(struct yaffs_dev *dev) { - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, - mode, uid, gid, NULL, NULL, 0); -} + struct yaffs_obj *obj; + int n_caches = dev->param.n_caches; + int i; -yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid, __u32 rdev) -{ - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, - uid, gid, NULL, NULL, rdev); -} + /* Find a dirty object in the cache and flush it... + * until there are no further dirty objects. + */ + do { + obj = NULL; + for (i = 0; i < n_caches && !obj; i++) { + if (dev->cache[i].object && dev->cache[i].dirty) + obj = dev->cache[i].object; + } + if (obj) + yaffs_flush_file_cache(obj); + } while (obj); -yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid, - const YCHAR * alias) -{ - return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, - uid, gid, NULL, alias, 0); } -/* yaffs_Link returns the object id of the equivalent object.*/ -yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name, - yaffs_Object * equivalentObject) +/* Grab us a cache chunk for use. + * First look for an empty one. + * Then look for the least recently used non-dirty one. + * Then look for the least recently used dirty one...., flush and look again. + */ +static struct yaffs_cache *yaffs_grab_chunk_worker(struct yaffs_dev *dev) { - /* Get the real object in case we were fed a hard link as an equivalent object */ - equivalentObject = yaffs_GetEquivalentObject(equivalentObject); + int i; - if (yaffs_MknodObject - (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0, - equivalentObject, NULL, 0)) { - return equivalentObject; - } else { - return NULL; + if (dev->param.n_caches > 0) { + for (i = 0; i < dev->param.n_caches; i++) { + if (!dev->cache[i].object) + return &dev->cache[i]; + } } - + return NULL; } -static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir, - const YCHAR * newName, int force, int shadows) +static struct yaffs_cache *yaffs_grab_chunk_cache(struct yaffs_dev *dev) { - int unlinkOp; - int deleteOp; - - yaffs_Object *existingTarget; - - if (newDir == NULL) { - newDir = obj->parent; /* use the old directory */ - } - - if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragendy: yaffs_ChangeObjectName: newDir is not a directory" - TENDSTR))); - YBUG(); - } - - /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */ - if (obj->myDev->isYaffs2) { - unlinkOp = (newDir == obj->myDev->unlinkedDir); - } else { - unlinkOp = (newDir == obj->myDev->unlinkedDir - && obj->variantType == YAFFS_OBJECT_TYPE_FILE); - } + struct yaffs_cache *cache; + struct yaffs_obj *the_obj; + int usage; + int i; + int pushout; - deleteOp = (newDir == obj->myDev->deletedDir); + if (dev->param.n_caches < 1) + return NULL; - existingTarget = yaffs_FindObjectByName(newDir, newName); + /* Try find a non-dirty one... */ - /* 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 ((unlinkOp || - deleteOp || - force || - (shadows > 0) || - !existingTarget) && - newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) { - yaffs_SetObjectName(obj, newName); - obj->dirty = 1; + cache = yaffs_grab_chunk_worker(dev); - yaffs_AddObjectToDirectory(newDir, obj); + if (!cache) { + /* They were all dirty, find the LRU object and flush + * its cache, then find again. + * NB what's here is not very accurate, + * we actually flush the object with the LRU chunk. + */ - if (unlinkOp) - obj->unlinked = 1; + /* With locking we can't assume we can use entry zero, + * Set the_obj to a valid pointer for Coverity. */ + the_obj = dev->cache[0].object; + usage = -1; + cache = NULL; + pushout = -1; + + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object && + !dev->cache[i].locked && + (dev->cache[i].last_use < usage || + !cache)) { + usage = dev->cache[i].last_use; + the_obj = dev->cache[i].object; + cache = &dev->cache[i]; + pushout = i; + } + } - /* If it is a deletion then we mark it as a shrink for gc purposes. */ - if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows)>= 0) - return YAFFS_OK; + if (!cache || cache->dirty) { + /* Flush and try again */ + yaffs_flush_file_cache(the_obj); + cache = yaffs_grab_chunk_worker(dev); + } } - - return YAFFS_FAIL; + return cache; } -int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName, - yaffs_Object * newDir, const YCHAR * newName) +/* Find a cached chunk */ +static struct yaffs_cache *yaffs_find_chunk_cache(const struct yaffs_obj *obj, + int chunk_id) { - yaffs_Object *obj; - yaffs_Object *existingTarget; - int force = 0; + struct yaffs_dev *dev = obj->my_dev; + int i; -#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 (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) { - force = 1; - } -#endif + if (dev->param.n_caches < 1) + return NULL; - obj = yaffs_FindObjectByName(oldDir, oldName); - /* Check new name to long. */ - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK && - yaffs_strlen(newName) > YAFFS_MAX_ALIAS_LENGTH) - /* ENAMETOOLONG */ - return YAFFS_FAIL; - else if (obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK && - yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH) - /* ENAMETOOLONG */ - return YAFFS_FAIL; - - if (obj && obj->renameAllowed) { - - /* Now do the handling for an existing target, if there is one */ - - existingTarget = yaffs_FindObjectByName(newDir, newName); - if (existingTarget && - existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY && - !list_empty(&existingTarget->variant.directoryVariant.children)) { - /* There is a target that is a non-empty directory, so we fail */ - return YAFFS_FAIL; /* EEXIST or ENOTEMPTY */ - } else if (existingTarget && existingTarget != obj) { - /* Nuke the target first, using shadowing, - * but only if it isn't the same object - */ - yaffs_ChangeObjectName(obj, newDir, newName, force, - existingTarget->objectId); - yaffs_UnlinkObject(existingTarget); - } + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object == obj && + dev->cache[i].chunk_id == chunk_id) { + dev->cache_hits++; - return yaffs_ChangeObjectName(obj, newDir, newName, 1, 0); + return &dev->cache[i]; + } } - return YAFFS_FAIL; + return NULL; } -/*------------------------- Block Management and Page Allocation ----------------*/ - -static int yaffs_InitialiseBlocks(yaffs_Device * dev) +/* Mark the chunk for the least recently used algorithym */ +static void yaffs_use_cache(struct yaffs_dev *dev, struct yaffs_cache *cache, + int is_write) { - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; - - dev->blockInfo = NULL; - dev->chunkBits = NULL; - - dev->allocationBlock = -1; /* force it to get a new one */ + int i; - /* If the first allocation strategy fails, thry the alternate one */ - dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo)); - if(!dev->blockInfo){ - dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo)); - dev->blockInfoAlt = 1; - } - else - dev->blockInfoAlt = 0; + if (dev->param.n_caches < 1) + return; - if(dev->blockInfo){ + if (dev->cache_last_use < 0 || + dev->cache_last_use > 100000000) { + /* Reset the cache usages */ + for (i = 1; i < dev->param.n_caches; i++) + dev->cache[i].last_use = 0; - /* Set up dynamic blockinfo stuff. */ - dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */ - dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks); - if(!dev->chunkBits){ - dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks); - dev->chunkBitsAlt = 1; - } - else - dev->chunkBitsAlt = 0; + dev->cache_last_use = 0; } + dev->cache_last_use++; + cache->last_use = dev->cache_last_use; - if (dev->blockInfo && dev->chunkBits) { - memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo)); - memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks); - return YAFFS_OK; - } - - return YAFFS_FAIL; - + if (is_write) + cache->dirty = 1; } -static void yaffs_DeinitialiseBlocks(yaffs_Device * dev) +/* Invalidate a single cache page. + * Do this when a whole page gets written, + * ie the short cache for this page is no longer valid. + */ +static void yaffs_invalidate_chunk_cache(struct yaffs_obj *object, int chunk_id) { - if(dev->blockInfoAlt && dev->blockInfo) - YFREE_ALT(dev->blockInfo); - else if(dev->blockInfo) - YFREE(dev->blockInfo); + struct yaffs_cache *cache; - dev->blockInfoAlt = 0; + if (object->my_dev->param.n_caches > 0) { + cache = yaffs_find_chunk_cache(object, chunk_id); - dev->blockInfo = NULL; - - if(dev->chunkBitsAlt && dev->chunkBits) - YFREE_ALT(dev->chunkBits); - else if(dev->chunkBits) - YFREE(dev->chunkBits); - dev->chunkBitsAlt = 0; - dev->chunkBits = NULL; + if (cache) + cache->object = NULL; + } } -static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device * dev, - yaffs_BlockInfo * bi) +/* Invalidate all the cache pages associated with this object + * Do this whenever ther file is deleted or resized. + */ +static void yaffs_invalidate_whole_cache(struct yaffs_obj *in) { int i; - __u32 seq; - yaffs_BlockInfo *b; - - if (!dev->isYaffs2) - return 1; /* disqualification only applies to yaffs2. */ + struct yaffs_dev *dev = in->my_dev; - if (!bi->hasShrinkHeader) - return 1; /* can gc */ - - /* Find the oldest dirty sequence number if we don't know it and save it - * so we don't have to keep recomputing it. - */ - if (!dev->oldestDirtySequence) { - seq = dev->sequenceNumber; - - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; - i++) { - b = yaffs_GetBlockInfo(dev, i); - if (b->blockState == YAFFS_BLOCK_STATE_FULL && - (b->pagesInUse - b->softDeletions) < - dev->nChunksPerBlock && b->sequenceNumber < seq) { - seq = b->sequenceNumber; - } + if (dev->param.n_caches > 0) { + /* Invalidate it. */ + for (i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].object == in) + dev->cache[i].object = NULL; } - dev->oldestDirtySequence = seq; } - - /* Can't do gc of this block if there are any blocks older than this one that have - * discarded pages. - */ - return (bi->sequenceNumber <= dev->oldestDirtySequence); - } -/* FindDiretiestBlock is used to select the dirtiest block (or close enough) - * for garbage collection. - */ - -static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev, - int aggressive) +static void yaffs_unhash_obj(struct yaffs_obj *obj) { + int bucket; + struct yaffs_dev *dev = obj->my_dev; - int b = dev->currentDirtyChecker; - - int i; - int iterations; - int dirtiest = -1; - int pagesInUse = 0; - int prioritised=0; - yaffs_BlockInfo *bi; - int pendingPrioritisedExist = 0; - - /* First let's see if we need to grab a prioritised block */ - if(dev->hasPendingPrioritisedGCs){ - for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){ - - bi = yaffs_GetBlockInfo(dev, i); - //yaffs_VerifyBlock(dev,bi,i); - - if(bi->gcPrioritise) { - pendingPrioritisedExist = 1; - if(bi->blockState == YAFFS_BLOCK_STATE_FULL && - yaffs_BlockNotDisqualifiedFromGC(dev, bi)){ - pagesInUse = (bi->pagesInUse - bi->softDeletions); - dirtiest = i; - prioritised = 1; - aggressive = 1; /* Fool the non-aggressive skip logiv below */ - } - } - } - - if(!pendingPrioritisedExist) /* None found, so we can clear this */ - dev->hasPendingPrioritisedGCs = 0; + /* If it is still linked into the bucket list, free from the list */ + if (!list_empty(&obj->hash_link)) { + list_del_init(&obj->hash_link); + bucket = yaffs_hash_fn(obj->obj_id); + dev->obj_bucket[bucket].count--; } +} - /* 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. - */ - - dev->nonAggressiveSkip--; +/* FreeObject frees up a Object and puts it back on the free list */ +static void yaffs_free_obj(struct yaffs_obj *obj) +{ + struct yaffs_dev *dev; - if (!aggressive && (dev->nonAggressiveSkip > 0)) { - return -1; + if (!obj) { + BUG(); + return; } + dev = obj->my_dev; + yaffs_trace(YAFFS_TRACE_OS, "FreeObject %p inode %p", + obj, obj->my_inode); + if (obj->parent) + BUG(); + if (!list_empty(&obj->siblings)) + BUG(); - if(!prioritised) - pagesInUse = - (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1; - - if (aggressive) { - iterations = - dev->internalEndBlock - dev->internalStartBlock + 1; - } else { - iterations = - dev->internalEndBlock - dev->internalStartBlock + 1; - iterations = iterations / 16; - if (iterations > 200) { - iterations = 200; - } + 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; } - for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) { - b++; - if (b < dev->internalStartBlock || b > dev->internalEndBlock) { - b = dev->internalStartBlock; - } + yaffs_unhash_obj(obj); - if (b < dev->internalStartBlock || b > dev->internalEndBlock) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> Block %d is not valid" TENDSTR), b)); - YBUG(); - } + yaffs_free_raw_obj(dev, obj); + dev->n_obj--; + dev->checkpoint_blocks_required = 0; /* force recalculation */ +} - bi = yaffs_GetBlockInfo(dev, b); +void yaffs_handle_defered_free(struct yaffs_obj *obj) +{ + if (obj->defered_free) + yaffs_free_obj(obj); +} -#if 0 - if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) { - dirtiest = b; - pagesInUse = 0; - } - else -#endif +static int yaffs_generic_obj_del(struct yaffs_obj *in) +{ + /* Iinvalidate the file's data in the cache, without flushing. */ + yaffs_invalidate_whole_cache(in); - if (bi->blockState == YAFFS_BLOCK_STATE_FULL && - (bi->pagesInUse - bi->softDeletions) < pagesInUse && - yaffs_BlockNotDisqualifiedFromGC(dev, bi)) { - dirtiest = b; - pagesInUse = (bi->pagesInUse - bi->softDeletions); - } + if (in->my_dev->param.is_yaffs2 && in->parent != in->my_dev->del_dir) { + /* Move to unlinked directory so we have a deletion record */ + yaffs_change_obj_name(in, in->my_dev->del_dir, _Y("deleted"), 0, + 0); } - dev->currentDirtyChecker = b; + yaffs_remove_obj_from_dir(in); + yaffs_chunk_del(in->my_dev, in->hdr_chunk, 1, __LINE__); + in->hdr_chunk = 0; - if (dirtiest > 0) { - T(YAFFS_TRACE_GC, - (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest, - dev->nChunksPerBlock - pagesInUse,prioritised)); - } + yaffs_free_obj(in); + return YAFFS_OK; - dev->oldestDirtySequence = 0; +} - if (dirtiest > 0) { - dev->nonAggressiveSkip = 4; - } +static void yaffs_soft_del_file(struct yaffs_obj *obj) +{ + if (!obj->deleted || + obj->variant_type != YAFFS_OBJECT_TYPE_FILE || + obj->soft_del) + return; - return dirtiest; + 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; + yaffs_trace(YAFFS_TRACE_TRACING, + "yaffs: Deleting empty file %d", + 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; + } } -static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo) +/* 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 struct yaffs_tnode *yaffs_prune_worker(struct yaffs_dev *dev, + struct yaffs_tnode *tn, u32 level, + int del0) { - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo); + int i; + int has_data; - int erasedOk = 0; + if (!tn) + return tn; - /* 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_BlockBecameDirty block %d state %d %s"TENDSTR), - blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : "")); + has_data = 0; - bi->blockState = YAFFS_BLOCK_STATE_DIRTY; + 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 (!bi->needsRetiring) { - yaffs_InvalidateCheckpoint(dev); - erasedOk = yaffs_EraseBlockInNAND(dev, blockNo); - if (!erasedOk) { - dev->nErasureFailures++; - T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Erasure failed %d" TENDSTR), blockNo)); + if (tn->internal[i]) + has_data++; } - } + } else { + int tnode_size_u32 = dev->tnode_size / sizeof(u32); + u32 *map = (u32 *) tn; - if (erasedOk && - ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) { - int i; - for (i = 0; i < dev->nChunksPerBlock; i++) { - if (!yaffs_CheckChunkErased - (dev, blockNo * dev->nChunksPerBlock + i)) { - T(YAFFS_TRACE_ERROR, - (TSTR - (">>Block %d erasure supposedly OK, but chunk %d not erased" - TENDSTR), blockNo, i)); - } + for (i = 0; !has_data && i < tnode_size_u32; i++) { + if (map[i]) + has_data++; } } - if (erasedOk) { - /* Clean it up... */ - bi->blockState = YAFFS_BLOCK_STATE_EMPTY; - dev->nErasedBlocks++; - bi->pagesInUse = 0; - bi->softDeletions = 0; - bi->hasShrinkHeader = 0; - bi->skipErasedCheck = 1; /* This is clean, so no need to check */ - bi->gcPrioritise = 0; - yaffs_ClearChunkBits(dev, blockNo); - - T(YAFFS_TRACE_ERASE, - (TSTR("Erased block %d" TENDSTR), blockNo)); - } else { - dev->nFreeChunks -= dev->nChunksPerBlock; /* We lost a block of free space */ - - yaffs_RetireBlock(dev, blockNo); - T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>> Block %d retired" TENDSTR), blockNo)); + if (has_data == 0 && del0) { + /* Free and return NULL */ + yaffs_free_tnode(dev, tn); + tn = NULL; } + return tn; } -static int yaffs_FindBlockForAllocation(yaffs_Device * dev) +static int yaffs_prune_tree(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct) { int i; + int has_data; + int done = 0; + struct yaffs_tnode *tn; - yaffs_BlockInfo *bi; + if (file_struct->top_level < 1) + return YAFFS_OK; - if (dev->nErasedBlocks < 1) { - /* Hoosterman we've got a problem. - * Can't get space to gc - */ - T(YAFFS_TRACE_ERROR, - (TSTR("yaffs tragedy: no more eraased blocks" TENDSTR))); + file_struct->top = + yaffs_prune_worker(dev, file_struct->top, file_struct->top_level, 0); - return -1; - } + /* 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) + */ - /* Find an empty block. */ + while (file_struct->top_level && !done) { + tn = file_struct->top; - for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) { - dev->allocationBlockFinder++; - if (dev->allocationBlockFinder < dev->internalStartBlock - || dev->allocationBlockFinder > dev->internalEndBlock) { - dev->allocationBlockFinder = dev->internalStartBlock; + has_data = 0; + for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) { + if (tn->internal[i]) + has_data++; } - bi = yaffs_GetBlockInfo(dev, dev->allocationBlockFinder); - - if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) { - bi->blockState = YAFFS_BLOCK_STATE_ALLOCATING; - dev->sequenceNumber++; - bi->sequenceNumber = dev->sequenceNumber; - dev->nErasedBlocks--; - T(YAFFS_TRACE_ALLOCATE, - (TSTR("Allocated block %d, seq %d, %d left" TENDSTR), - dev->allocationBlockFinder, dev->sequenceNumber, - dev->nErasedBlocks)); - return dev->allocationBlockFinder; + if (!has_data) { + file_struct->top = tn->internal[0]; + file_struct->top_level--; + yaffs_free_tnode(dev, tn); + } else { + done = 1; } } - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("yaffs tragedy: no more eraased blocks, but there should have been %d" - TENDSTR), dev->nErasedBlocks)); - - return -1; + return YAFFS_OK; } +/*-------------------- End of File Structure functions.-------------------*/ -// Check if there's space to allocate... -// Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()? -static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev) +/* alloc_empty_obj gets us a clean Object.*/ +static struct yaffs_obj *yaffs_alloc_empty_obj(struct yaffs_dev *dev) { - int reservedChunks; - int reservedBlocks = dev->nReservedBlocks; - int checkpointBlocks; + struct yaffs_obj *obj = yaffs_alloc_raw_obj(dev); - checkpointBlocks = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint; - if(checkpointBlocks < 0) - checkpointBlocks = 0; + if (!obj) + return obj; - reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock); + dev->n_obj++; - return (dev->nFreeChunks > reservedChunks); -} + /* Now sweeten it up... */ -static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr) -{ - int retVal; - yaffs_BlockInfo *bi; + memset(obj, 0, sizeof(struct yaffs_obj)); + obj->being_created = 1; - if (dev->allocationBlock < 0) { - /* Get next block to allocate off */ - dev->allocationBlock = yaffs_FindBlockForAllocation(dev); - dev->allocationPage = 0; - } + obj->my_dev = dev; + obj->hdr_chunk = 0; + obj->variant_type = YAFFS_OBJECT_TYPE_UNKNOWN; + INIT_LIST_HEAD(&(obj->hard_links)); + INIT_LIST_HEAD(&(obj->hash_link)); + INIT_LIST_HEAD(&obj->siblings); - if (!useReserve && !yaffs_CheckSpaceForAllocation(dev)) { - /* Not enough space to allocate unless we're allowed to use the reserve. */ - return -1; + /* Now make the directory sane */ + if (dev->root_dir) { + obj->parent = dev->root_dir; + list_add(&(obj->siblings), + &dev->root_dir->variant.dir_variant.children); } - if (dev->nErasedBlocks < dev->nReservedBlocks - && dev->allocationPage == 0) { - T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR))); - } - - /* Next page please.... */ - if (dev->allocationBlock >= 0) { - bi = yaffs_GetBlockInfo(dev, dev->allocationBlock); - - retVal = (dev->allocationBlock * dev->nChunksPerBlock) + - dev->allocationPage; - bi->pagesInUse++; - yaffs_SetChunkBit(dev, dev->allocationBlock, - dev->allocationPage); - - dev->allocationPage++; - - dev->nFreeChunks--; - - /* If the block is full set the state to full */ - if (dev->allocationPage >= dev->nChunksPerBlock) { - bi->blockState = YAFFS_BLOCK_STATE_FULL; - dev->allocationBlock = -1; - } - - if(blockUsedPtr) - *blockUsedPtr = bi; + /* 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); - return retVal; - } + obj->being_created = 0; - T(YAFFS_TRACE_ERROR, - (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR))); + dev->checkpoint_blocks_required = 0; /* force recalculation */ - return -1; + return obj; } -static int yaffs_GetErasedChunks(yaffs_Device * dev) +static int yaffs_find_nice_bucket(struct yaffs_dev *dev) { - int n; + int i; + int l = 999; + int lowest = 999999; - n = dev->nErasedBlocks * dev->nChunksPerBlock; + /* Search for the shortest list or one that + * isn't too long. + */ - if (dev->allocationBlock > 0) { - n += (dev->nChunksPerBlock - dev->allocationPage); + 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 n; - + return l; } -static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block) +static int yaffs_new_obj_id(struct yaffs_dev *dev) { - int oldChunk; - int newChunk; - int chunkInBlock; - int markNAND; - int retVal = YAFFS_OK; - int cleanups = 0; - int i; - int isCheckpointBlock; - int matchingChunk; - - int chunksBefore = yaffs_GetErasedChunks(dev); - int chunksAfter; - - yaffs_ExtendedTags tags; - - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, block); - - yaffs_Object *object; - - isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT); - - bi->blockState = YAFFS_BLOCK_STATE_COLLECTING; - - T(YAFFS_TRACE_TRACING, - (TSTR("Collecting block %d, in use %d, shrink %d, " TENDSTR), block, - bi->pagesInUse, bi->hasShrinkHeader)); - - /*yaffs_VerifyFreeChunks(dev); */ - - bi->hasShrinkHeader = 0; /* clear the flag so that the block can erase */ + int bucket = yaffs_find_nice_bucket(dev); + int found = 0; + struct list_head *i; + u32 n = (u32) bucket; - /* Take off the number of soft deleted entries because - * they're going to get really deleted during GC. + /* Now find an object value that has not already been taken + * by scanning the list. */ - dev->nFreeChunks -= bi->softDeletions; - - dev->isDoingGC = 1; - - if (isCheckpointBlock || - !yaffs_StillSomeChunkBits(dev, block)) { - T(YAFFS_TRACE_TRACING, - (TSTR - ("Collecting block %d that has no chunks in use" TENDSTR), - block)); - yaffs_BlockBecameDirty(dev, block); - } else { - - __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__); - - yaffs_VerifyBlock(dev,bi,block); - - for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock; - chunkInBlock < dev->nChunksPerBlock - && yaffs_StillSomeChunkBits(dev, block); - chunkInBlock++, oldChunk++) { - if (yaffs_CheckChunkBit(dev, block, chunkInBlock)) { - - /* This page is in use and might need to be copied off */ - markNAND = 1; - - yaffs_InitialiseTags(&tags); - - yaffs_ReadChunkWithTagsFromNAND(dev, oldChunk, - buffer, &tags); - - object = - yaffs_FindObjectByNumber(dev, - tags.objectId); - - T(YAFFS_TRACE_GC_DETAIL, - (TSTR - ("Collecting page %d, %d %d %d " TENDSTR), - chunkInBlock, tags.objectId, tags.chunkId, - tags.byteCount)); - - if(object && !yaffs_SkipVerification(dev)){ - if(tags.chunkId == 0) - matchingChunk = object->chunkId; - else if(object->softDeleted) - matchingChunk = oldChunk; /* Defeat the test */ - else - matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL); - - if(oldChunk != matchingChunk) - T(YAFFS_TRACE_ERROR, - (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR), - oldChunk,matchingChunk,tags.objectId, tags.chunkId)); - - } - - if (!object) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("page %d in gc has no object: %d %d %d " - TENDSTR), oldChunk, - tags.objectId, tags.chunkId, tags.byteCount)); - } - - if (object && object->deleted - && tags.chunkId != 0) { - /* Data chunk in a 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. - */ - - object->nDataChunks--; - - if (object->nDataChunks <= 0) { - /* remeber to clean up the object */ - dev->gcCleanupList[cleanups] = - tags.objectId; - cleanups++; - } - markNAND = 0; - } else if (0 - /* Todo object && object->deleted && object->nDataChunks == 0 */ - ) { - /* Deleted object header with no data chunks. - * Can be discarded and the file deleted. - */ - object->chunkId = 0; - yaffs_FreeTnode(object->myDev, - object->variant. - fileVariant.top); - object->variant.fileVariant.top = NULL; - yaffs_DoGenericObjectDeletion(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.serialNumber++; - - dev->nGCCopies++; - - if (tags.chunkId == 0) { - /* It is an object Id, - * We need to nuke the shrinkheader flags first - * We no longer want the shrinkHeader flag since its work is done - * and if it is left in place it will mess up scanning. - * Also, clear out any shadowing stuff - */ - - yaffs_ObjectHeader *oh; - oh = (yaffs_ObjectHeader *)buffer; - oh->isShrink = 0; - oh->shadowsObject = -1; - tags.extraShadows = 0; - tags.extraIsShrinkHeader = 0; - - yaffs_VerifyObjectHeader(object,oh,&tags,1); - } - - newChunk = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1); - - if (newChunk < 0) { - retVal = YAFFS_FAIL; - } else { - - /* Ok, now fix up the Tnodes etc. */ - - if (tags.chunkId == 0) { - /* It's a header */ - object->chunkId = newChunk; - object->serial = tags.serialNumber; - } else { - /* It's a data chunk */ - yaffs_PutChunkIntoFile - (object, - tags.chunkId, - newChunk, 0); - } - } + while (!found) { + found = 1; + n += YAFFS_NOBJECT_BUCKETS; + if (1 || dev->obj_bucket[bucket].count > 0) { + list_for_each(i, &dev->obj_bucket[bucket].list) { + /* If there is already one in the list */ + if (i && list_entry(i, struct yaffs_obj, + hash_link)->obj_id == n) { + found = 0; } - - yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__); - } } + } + return n; +} - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); +static void yaffs_hash_obj(struct yaffs_obj *in) +{ + int bucket = yaffs_hash_fn(in->obj_id); + struct yaffs_dev *dev = in->my_dev; + list_add(&in->hash_link, &dev->obj_bucket[bucket].list); + dev->obj_bucket[bucket].count++; +} - /* Do any required cleanups */ - for (i = 0; i < cleanups; i++) { - /* Time to delete the file too */ - object = - yaffs_FindObjectByNumber(dev, - dev->gcCleanupList[i]); - if (object) { - yaffs_FreeTnode(dev, - object->variant.fileVariant. - top); - object->variant.fileVariant.top = NULL; - T(YAFFS_TRACE_GC, - (TSTR - ("yaffs: About to finally delete object %d" - TENDSTR), object->objectId)); - yaffs_DoGenericObjectDeletion(object); - object->myDev->nDeletedFiles--; - } +struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number) +{ + int bucket = yaffs_hash_fn(number); + struct list_head *i; + struct yaffs_obj *in; + list_for_each(i, &dev->obj_bucket[bucket].list) { + /* Look if it is in the list */ + in = list_entry(i, struct yaffs_obj, hash_link); + if (in->obj_id == number) { + /* Don't show if it is defered free */ + if (in->defered_free) + return NULL; + return in; } - - } - - yaffs_VerifyCollectedBlock(dev,bi,block); - - if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) { - T(YAFFS_TRACE_GC, - (TSTR - ("gc did not increase free chunks before %d after %d" - TENDSTR), chunksBefore, chunksAfter)); } - dev->isDoingGC = 0; - - return retVal; + return NULL; } -/* 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_CheckGarbageCollection(yaffs_Device * dev) +struct yaffs_obj *yaffs_new_obj(struct yaffs_dev *dev, int number, + enum yaffs_obj_type type) { - int block; - int aggressive; - int gcOk = YAFFS_OK; - int maxTries = 0; + struct yaffs_obj *the_obj = NULL; + struct yaffs_tnode *tn = NULL; - int checkpointBlockAdjust; + if (number < 0) + number = yaffs_new_obj_id(dev); - if (dev->isDoingGC) { - /* Bail out so we don't get recursive gc */ - return YAFFS_OK; + if (type == YAFFS_OBJECT_TYPE_FILE) { + tn = yaffs_get_tnode(dev); + if (!tn) + return NULL; } - /* This loop should pass the first time. - * We'll only see looping here if the erase of the collected block fails. - */ - - do { - maxTries++; + the_obj = yaffs_alloc_empty_obj(dev); + if (!the_obj) { + if (tn) + yaffs_free_tnode(dev, tn); + return NULL; + } - checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint); - if(checkpointBlockAdjust < 0) - checkpointBlockAdjust = 0; + 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; + yaffs_load_current_time(the_obj, 1, 1); - if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust + 2)) { - /* We need a block soon...*/ - aggressive = 1; - } else { - /* We're in no hurry */ - aggressive = 0; - } - - block = yaffs_FindBlockForGarbageCollection(dev, aggressive); + 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 = + yaffs_max_file_size(dev); + the_obj->variant.file_variant.top_level = 0; + the_obj->variant.file_variant.top = tn; + break; + case YAFFS_OBJECT_TYPE_DIRECTORY: + INIT_LIST_HEAD(&the_obj->variant.dir_variant.children); + INIT_LIST_HEAD(&the_obj->variant.dir_variant.dirty); + break; + case YAFFS_OBJECT_TYPE_SYMLINK: + case YAFFS_OBJECT_TYPE_HARDLINK: + case YAFFS_OBJECT_TYPE_SPECIAL: + /* No action required */ + break; + case YAFFS_OBJECT_TYPE_UNKNOWN: + /* todo this should not happen */ + break; + } + return the_obj; +} - if (block > 0) { - dev->garbageCollections++; - if (!aggressive) { - dev->passiveGarbageCollections++; - } +static struct yaffs_obj *yaffs_create_fake_dir(struct yaffs_dev *dev, + int number, u32 mode) +{ - T(YAFFS_TRACE_GC, - (TSTR - ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR), - dev->nErasedBlocks, aggressive)); + struct yaffs_obj *obj = + yaffs_new_obj(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY); - gcOk = yaffs_GarbageCollectBlock(dev, block); - } + if (!obj) + return NULL; - if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) { - T(YAFFS_TRACE_GC, - (TSTR - ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d" - TENDSTR), dev->nErasedBlocks, maxTries, block)); - } - } while ((dev->nErasedBlocks < dev->nReservedBlocks) && (block > 0) - && (maxTries < 2)); + obj->fake = 1; /* it is fake so it might not use NAND */ + obj->rename_allowed = 0; + obj->unlink_allowed = 0; + obj->deleted = 0; + obj->unlinked = 0; + obj->yst_mode = mode; + obj->my_dev = dev; + obj->hdr_chunk = 0; /* Not a valid chunk. */ + return obj; - return aggressive ? gcOk : YAFFS_OK; } -/*------------------------- TAGS --------------------------------*/ -static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId, - int chunkInObject) +static void yaffs_init_tnodes_and_objs(struct yaffs_dev *dev) { - return (tags->chunkId == chunkInObject && - tags->objectId == objectId && !tags->chunkDeleted) ? 1 : 0; - -} + int i; + dev->n_obj = 0; + dev->n_tnodes = 0; + yaffs_init_raw_tnodes_and_objs(dev); -/*-------------------- Data file manipulation -----------------*/ + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + INIT_LIST_HEAD(&dev->obj_bucket[i].list); + dev->obj_bucket[i].count = 0; + } +} -static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode, - yaffs_ExtendedTags * tags) +struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, + int number, + enum yaffs_obj_type type) { - /*Get the Tnode, then get the level 0 offset chunk offset */ - yaffs_Tnode *tn; - int theChunk = -1; - yaffs_ExtendedTags localTags; - int retVal = -1; + struct yaffs_obj *the_obj = NULL; - yaffs_Device *dev = in->myDev; + if (number > 0) + the_obj = yaffs_find_by_number(dev, number); - if (!tags) { - /* Passed a NULL, so use our own tags space */ - tags = &localTags; - } - - tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); + if (!the_obj) + the_obj = yaffs_new_obj(dev, number, type); - if (tn) { - theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode); + return the_obj; - retVal = - yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, - chunkInInode); - } - return retVal; } -static int yaffs_FindAndDeleteChunkInFile(yaffs_Object * in, int chunkInInode, - yaffs_ExtendedTags * tags) +YCHAR *yaffs_clone_str(const YCHAR *str) { - /* Get the Tnode, then get the level 0 offset chunk offset */ - yaffs_Tnode *tn; - int theChunk = -1; - yaffs_ExtendedTags localTags; + YCHAR *new_str = NULL; + int len; - yaffs_Device *dev = in->myDev; - int retVal = -1; + if (!str) + str = _Y(""); - if (!tags) { - /* Passed a NULL, so use our own tags space */ - tags = &localTags; + len = yaffs_strnlen(str, YAFFS_MAX_ALIAS_LENGTH); + new_str = kmalloc((len + 1) * sizeof(YCHAR), GFP_NOFS); + if (new_str) { + yaffs_strncpy(new_str, str, len); + new_str[len] = 0; } + return new_str; - tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode); - - if (tn) { - - theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode); +} +/* + *yaffs_update_parent() handles fixing a directories mtime and ctime when a new + * link (ie. name) is created or deleted in the directory. + * + * ie. + * create dir/a : update dir's mtime/ctime + * rm dir/a: update dir's mtime/ctime + * modify dir/a: don't update dir's mtimme/ctime + * + * This can be handled immediately or defered. Defering helps reduce the number + * of updates when many files in a directory are changed within a brief period. + * + * If the directory updating is defered then yaffs_update_dirty_dirs must be + * called periodically. + */ - retVal = - yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId, - chunkInInode); +static void yaffs_update_parent(struct yaffs_obj *obj) +{ + struct yaffs_dev *dev; - /* Delete the entry in the filestructure (if found) */ - if (retVal != -1) { - yaffs_PutLevel0Tnode(dev,tn,chunkInInode,0); + if (!obj) + return; + dev = obj->my_dev; + obj->dirty = 1; + yaffs_load_current_time(obj, 0, 1); + if (dev->param.defered_dir_update) { + struct list_head *link = &obj->variant.dir_variant.dirty; + + if (list_empty(link)) { + list_add(link, &dev->dirty_dirs); + yaffs_trace(YAFFS_TRACE_BACKGROUND, + "Added object %d to dirty directories", + obj->obj_id); } - } else { - /*T(("No level 0 found for %d\n", chunkInInode)); */ - } - if (retVal == -1) { - /* T(("Could not find %d to delete\n",chunkInInode)); */ + } else { + yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } - return retVal; } -#ifdef YAFFS_PARANOID - -static int yaffs_CheckFileSanity(yaffs_Object * in) +void yaffs_update_dirty_dirs(struct yaffs_dev *dev) { - int chunk; - int nChunks; - int fSize; - int failed = 0; - int objId; - yaffs_Tnode *tn; - yaffs_Tags localTags; - yaffs_Tags *tags = &localTags; - int theChunk; - int chunkDeleted; - - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) { - /* T(("Object not a file\n")); */ - return YAFFS_FAIL; - } - - objId = in->objectId; - fSize = in->variant.fileVariant.fileSize; - nChunks = - (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk; + struct list_head *link; + struct yaffs_obj *obj; + struct yaffs_dir_var *d_s; + union yaffs_obj_var *o_v; - for (chunk = 1; chunk <= nChunks; chunk++) { - tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant, - chunk); + yaffs_trace(YAFFS_TRACE_BACKGROUND, "Update dirty directories"); - if (tn) { + while (!list_empty(&dev->dirty_dirs)) { + link = dev->dirty_dirs.next; + list_del_init(link); - theChunk = yaffs_GetChunkGroupBase(dev,tn,chunk); + d_s = list_entry(link, struct yaffs_dir_var, dirty); + o_v = list_entry(d_s, union yaffs_obj_var, dir_variant); + obj = list_entry(o_v, struct yaffs_obj, variant); - if (yaffs_CheckChunkBits - (dev, theChunk / dev->nChunksPerBlock, - theChunk % dev->nChunksPerBlock)) { + yaffs_trace(YAFFS_TRACE_BACKGROUND, "Update directory %d", + obj->obj_id); - yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk, - tags, - &chunkDeleted); - if (yaffs_TagsMatch - (tags, in->objectId, chunk, chunkDeleted)) { - /* found it; */ - - } - } else { - - failed = 1; - } - - } else { - /* T(("No level 0 found for %d\n", chunk)); */ - } + if (obj->dirty) + yaffs_update_oh(obj, NULL, 0, 0, 0, NULL); } - - return failed ? YAFFS_FAIL : YAFFS_OK; } -#endif +/* + * 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 int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode, - int chunkInNAND, int inScan) +static struct yaffs_obj *yaffs_create_obj(enum yaffs_obj_type type, + struct yaffs_obj *parent, + const YCHAR *name, + u32 mode, + u32 uid, + u32 gid, + struct yaffs_obj *equiv_obj, + const YCHAR *alias_str, u32 rdev) { - /* NB inScan is zero unless scanning. - * For forward scanning, inScan is > 0; - * for backward scanning inScan is < 0 - */ - - yaffs_Tnode *tn; - yaffs_Device *dev = in->myDev; - int existingChunk; - yaffs_ExtendedTags existingTags; - yaffs_ExtendedTags newTags; - unsigned existingSerial, newSerial; - - if (in->variantType != 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 (!inScan) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("yaffs tragedy:attempt to put data chunk into a non-file" - TENDSTR))); - YBUG(); - } + struct yaffs_obj *in; + YCHAR *str = NULL; + struct yaffs_dev *dev = parent->my_dev; - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); - return YAFFS_OK; - } + /* 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; - tn = yaffs_AddOrFindLevel0Tnode(dev, - &in->variant.fileVariant, - chunkInInode, - NULL); - if (!tn) { - return YAFFS_FAIL; + if (type == YAFFS_OBJECT_TYPE_SYMLINK) { + str = yaffs_clone_str(alias_str); + if (!str) + return NULL; } - existingChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode); + in = yaffs_new_obj(dev, -1, type); - if (inScan != 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 (existingChunk != 0) { - /* NB Right now existing chunk will not be real chunkId if the device >= 32MB - * 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 (inScan > 0) { - /* Only do this for forward scanning */ - yaffs_ReadChunkWithTagsFromNAND(dev, - chunkInNAND, - NULL, &newTags); + if (!in) { + kfree(str); + return NULL; + } - /* Do a proper find */ - existingChunk = - yaffs_FindChunkInFile(in, chunkInInode, - &existingTags); - } + in->hdr_chunk = 0; + in->valid = 1; + in->variant_type = type; - if (existingChunk <= 0) { - /*Hoosterman - how did this happen? */ + in->yst_mode = mode; - T(YAFFS_TRACE_ERROR, - (TSTR - ("yaffs tragedy: existing chunk < 0 in scan" - TENDSTR))); + yaffs_attribs_init(in, gid, uid, rdev); - } + in->n_data_chunks = 0; - /* NB The deleted flags should be false, otherwise the chunks will - * not be loaded during a scan - */ + yaffs_set_obj_name(in, name); + in->dirty = 1; - newSerial = newTags.serialNumber; - existingSerial = existingTags.serialNumber; + yaffs_add_obj_to_dir(parent, in); - if ((inScan > 0) && - (in->myDev->isYaffs2 || - existingChunk <= 0 || - ((existingSerial + 1) & 3) == newSerial)) { - /* Forward scanning. - * Use new - * Delete the old one and drop through to update the tnode - */ - yaffs_DeleteChunk(dev, existingChunk, 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_DeleteChunk(dev, chunkInNAND, 1, - __LINE__); - return YAFFS_OK; - } - } + 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; + list_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 (existingChunk == 0) { - in->nDataChunks++; + if (yaffs_update_oh(in, name, 0, 0, 0, NULL) < 0) { + /* Could not create the object header, fail */ + yaffs_del_obj(in); + in = NULL; } - yaffs_PutLevel0Tnode(dev,tn,chunkInInode,chunkInNAND); + if (in) + yaffs_update_parent(parent); - return YAFFS_OK; + return in; } -static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode, - __u8 * buffer) +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR *name, u32 mode, u32 uid, + u32 gid) { - int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL); + return yaffs_create_obj(YAFFS_OBJECT_TYPE_FILE, parent, name, mode, + uid, gid, NULL, NULL, 0); +} - if (chunkInNAND >= 0) { - return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND, - buffer,NULL); - } else { - T(YAFFS_TRACE_NANDACCESS, - (TSTR("Chunk %d not found zero instead" TENDSTR), - chunkInNAND)); - /* get sane (zero) data if you read a hole */ - memset(buffer, 0, in->myDev->nDataBytesPerChunk); - return 0; - } +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name, + u32 mode, u32 uid, u32 gid) +{ + return yaffs_create_obj(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name, + mode, uid, gid, NULL, NULL, 0); +} +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR *name, u32 mode, u32 uid, + u32 gid, u32 rdev) +{ + return yaffs_create_obj(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode, + uid, gid, NULL, NULL, rdev); } -void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn) +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR *name, u32 mode, u32 uid, + u32 gid, const YCHAR *alias) { - int block; - int page; - yaffs_ExtendedTags tags; - yaffs_BlockInfo *bi; + return yaffs_create_obj(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode, + uid, gid, NULL, alias, 0); +} - if (chunkId <= 0) - return; +/* yaffs_link_obj returns the object id of the equivalent object.*/ +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR * name, + struct yaffs_obj *equiv_obj) +{ + /* Get the real object in case we were fed a hard link obj */ + 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; - dev->nDeletions++; - block = chunkId / dev->nChunksPerBlock; - page = chunkId % dev->nChunksPerBlock; + return NULL; +} - if(!yaffs_CheckChunkBit(dev,block,page)) - T(YAFFS_TRACE_VERIFY, - (TSTR("Deleting invalid chunk %d"TENDSTR), - chunkId)); - bi = yaffs_GetBlockInfo(dev, block); - T(YAFFS_TRACE_DELETION, - (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId)); +/*---------------------- Block Management and Page Allocation -------------*/ - if (markNAND && - bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && !dev->isYaffs2) { +static void yaffs_deinit_blocks(struct yaffs_dev *dev) +{ + if (dev->block_info_alt && dev->block_info) + vfree(dev->block_info); + else + kfree(dev->block_info); - yaffs_InitialiseTags(&tags); + dev->block_info_alt = 0; - tags.chunkDeleted = 1; + dev->block_info = NULL; - yaffs_WriteChunkWithTagsToNAND(dev, chunkId, NULL, &tags); - yaffs_HandleUpdateChunk(dev, chunkId, &tags); - } else { - dev->nUnmarkedDeletions++; - } + if (dev->chunk_bits_alt && dev->chunk_bits) + vfree(dev->chunk_bits); + else + kfree(dev->chunk_bits); + dev->chunk_bits_alt = 0; + dev->chunk_bits = NULL; +} - /* Pull out of the management area. - * If the whole block became dirty, this will kick off an erasure. - */ - if (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || - bi->blockState == YAFFS_BLOCK_STATE_FULL || - bi->blockState == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) { - dev->nFreeChunks++; +static int yaffs_init_blocks(struct yaffs_dev *dev) +{ + int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; - yaffs_ClearChunkBit(dev, block, page); + dev->block_info = NULL; + dev->chunk_bits = NULL; + dev->alloc_block = -1; /* force it to get a new one */ - bi->pagesInUse--; + /* If the first allocation strategy fails, thry the alternate one */ + dev->block_info = + kmalloc(n_blocks * sizeof(struct yaffs_block_info), GFP_NOFS); + if (!dev->block_info) { + dev->block_info = + vmalloc(n_blocks * sizeof(struct yaffs_block_info)); + dev->block_info_alt = 1; + } else { + dev->block_info_alt = 0; + } - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState != YAFFS_BLOCK_STATE_ALLOCATING && - bi->blockState != YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - yaffs_BlockBecameDirty(dev, block); - } + if (!dev->block_info) + goto alloc_error; + /* Set up dynamic blockinfo stuff. Round up bytes. */ + dev->chunk_bit_stride = (dev->param.chunks_per_block + 7) / 8; + dev->chunk_bits = + kmalloc(dev->chunk_bit_stride * n_blocks, GFP_NOFS); + if (!dev->chunk_bits) { + dev->chunk_bits = + vmalloc(dev->chunk_bit_stride * n_blocks); + dev->chunk_bits_alt = 1; } else { - /* T(("Bad news deleting chunk %d\n",chunkId)); */ + dev->chunk_bits_alt = 0; } + if (!dev->chunk_bits) + goto alloc_error; -} - -static int yaffs_WriteChunkDataToObject(yaffs_Object * in, int chunkInInode, - const __u8 * buffer, int nBytes, - int useReserve) -{ - /* Find old chunk Need to do this to get serial number - * Write new one and patch into tree. - * Invalidate old tags. - */ - int prevChunkId; - yaffs_ExtendedTags prevTags; + memset(dev->block_info, 0, n_blocks * sizeof(struct yaffs_block_info)); + memset(dev->chunk_bits, 0, dev->chunk_bit_stride * n_blocks); + return YAFFS_OK; - int newChunkId; - yaffs_ExtendedTags newTags; +alloc_error: + yaffs_deinit_blocks(dev); + return YAFFS_FAIL; +} - yaffs_Device *dev = in->myDev; - yaffs_CheckGarbageCollection(dev); +void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no) +{ + struct yaffs_block_info *bi = yaffs_get_block_info(dev, block_no); + int erased_ok = 0; + int i; - /* Get the previous chunk at this location in the file if it exists */ - prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags); + /* If the block is still healthy erase it and mark as clean. + * If the block has had a data failure, then retire it. + */ - /* Set up new tags */ - yaffs_InitialiseTags(&newTags); + yaffs_trace(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE, + "yaffs_block_became_dirty block %d state %d %s", + block_no, bi->block_state, + (bi->needs_retiring) ? "needs retiring" : ""); - newTags.chunkId = chunkInInode; - newTags.objectId = in->objectId; - newTags.serialNumber = - (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1; - newTags.byteCount = nBytes; + yaffs2_clear_oldest_dirty_seq(dev, bi); - newChunkId = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, - useReserve); + bi->block_state = YAFFS_BLOCK_STATE_DIRTY; - if (newChunkId >= 0) { - yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0); + /* If this is the block being garbage collected then stop gc'ing */ + if (block_no == dev->gc_block) + dev->gc_block = 0; - if (prevChunkId >= 0) { - yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__); + /* 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++; + yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, + "**>> Erasure failed %d", block_no); } - - yaffs_CheckFileSanity(in); } - return newChunkId; -} - -/* UpdateObjectHeader updates the header on NAND for an object. - * If name is not NULL, then that new name is used. - */ -int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force, - int isShrink, int shadows) -{ - - yaffs_BlockInfo *bi; - - yaffs_Device *dev = in->myDev; - - int prevChunkId; - int retVal = 0; - - int newChunkId; - yaffs_ExtendedTags newTags; - yaffs_ExtendedTags oldTags; - - __u8 *buffer = NULL; - YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1]; - - yaffs_ObjectHeader *oh = NULL; - - yaffs_strcpy(oldName,"silly old name"); + /* Verify erasure if needed */ + if (erased_ok && + ((yaffs_trace_mask & YAFFS_TRACE_ERASE) || + !yaffs_skip_verification(dev))) { + for (i = 0; i < dev->param.chunks_per_block; i++) { + if (!yaffs_check_chunk_erased(dev, + block_no * dev->param.chunks_per_block + i)) { + yaffs_trace(YAFFS_TRACE_ERROR, + ">>Block %d erasure supposedly OK, but chunk %d not erased", + block_no, i); + } + } + } - if (!in->fake || force) { + if (!erased_ok) { + /* We lost a block of free space */ + dev->n_free_chunks -= dev->param.chunks_per_block; + yaffs_retire_block(dev, block_no); + yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, + "**>> Block %d retired", block_no); + return; + } - yaffs_CheckGarbageCollection(dev); - yaffs_CheckObjectDetailsLoaded(in); + /* 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; /* Clean, so no need to check */ + bi->gc_prioritise = 0; + bi->has_summary = 0; + + yaffs_clear_chunk_bits(dev, block_no); + + yaffs_trace(YAFFS_TRACE_ERASE, "Erased block %d", block_no); +} + +static inline int yaffs_gc_process_chunk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, + int old_chunk, u8 *buffer) +{ + int new_chunk; + int mark_flash = 1; + struct yaffs_ext_tags tags; + struct yaffs_obj *object; + int matching_chunk; + int ret_val = YAFFS_OK; + + memset(&tags, 0, sizeof(tags)); + yaffs_rd_chunk_tags_nand(dev, old_chunk, + buffer, &tags); + object = yaffs_find_by_number(dev, tags.obj_id); + + yaffs_trace(YAFFS_TRACE_GC_DETAIL, + "Collecting chunk in block %d, %d %d %d ", + 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) + /* Defeat the test */ + matching_chunk = old_chunk; + else + matching_chunk = + yaffs_find_chunk_in_file + (object, tags.chunk_id, + NULL); + + if (old_chunk != matching_chunk) + yaffs_trace(YAFFS_TRACE_ERROR, + "gc: page in gc mismatch: %d %d %d %d", + old_chunk, + matching_chunk, + tags.obj_id, + tags.chunk_id); + } + + if (!object) { + yaffs_trace(YAFFS_TRACE_ERROR, + "page %d in gc has no object: %d %d %d ", + 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. + */ - buffer = yaffs_GetTempBuffer(in->myDev, __LINE__); - oh = (yaffs_ObjectHeader *) buffer; + /* 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 obj */ + dev->gc_cleanup_list[dev->n_clean_ups] = tags.obj_id; + dev->n_clean_ups++; + } + mark_flash = 0; + } 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 since its + * work is done. + * Also need to clean up + * shadowing. + */ + struct yaffs_obj_hdr *oh; + oh = (struct yaffs_obj_hdr *) 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) { + yaffs_oh_size_load(oh, + object->variant.file_variant.file_size); + tags.extra_file_size = + object->variant.file_variant.file_size; + } - prevChunkId = in->chunkId; + 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 (prevChunkId >= 0) { - yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId, - buffer, &oldTags); + if (new_chunk < 0) { + ret_val = YAFFS_FAIL; + } else { - yaffs_VerifyObjectHeader(in,oh,&oldTags,0); + /* Now fix up the Tnodes etc. */ - memcpy(oldName, oh->name, sizeof(oh->name)); + 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 */ + 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__); + return ret_val; +} - memset(buffer, 0xFF, dev->nDataBytesPerChunk); +static int yaffs_gc_block(struct yaffs_dev *dev, int block, int whole_block) +{ + int old_chunk; + int ret_val = YAFFS_OK; + int i; + int is_checkpt_block; + int max_copies; + int chunks_before = yaffs_get_erased_chunks(dev); + int chunks_after; + struct yaffs_block_info *bi = yaffs_get_block_info(dev, block); - oh->type = in->variantType; - oh->yst_mode = in->yst_mode; - oh->shadowsObject = shadows; + is_checkpt_block = (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT); -#ifdef CONFIG_YAFFS_WINCE - oh->win_atime[0] = in->win_atime[0]; - oh->win_ctime[0] = in->win_ctime[0]; - oh->win_mtime[0] = in->win_mtime[0]; - oh->win_atime[1] = in->win_atime[1]; - oh->win_ctime[1] = in->win_ctime[1]; - oh->win_mtime[1] = in->win_mtime[1]; -#else - oh->yst_uid = in->yst_uid; - oh->yst_gid = in->yst_gid; - oh->yst_atime = in->yst_atime; - oh->yst_mtime = in->yst_mtime; - oh->yst_ctime = in->yst_ctime; - oh->yst_rdev = in->yst_rdev; -#endif - if (in->parent) { - oh->parentObjectId = in->parent->objectId; - } else { - oh->parentObjectId = 0; - } - - if (name && *name) { - memset(oh->name, 0, sizeof(oh->name)); - yaffs_strncpy(oh->name, name, YAFFS_MAX_NAME_LENGTH); - } else if (prevChunkId>=0) { - memcpy(oh->name, oldName, sizeof(oh->name)); - } else { - memset(oh->name, 0, sizeof(oh->name)); - } + yaffs_trace(YAFFS_TRACE_TRACING, + "Collecting block %d, in use %d, shrink %d, whole_block %d", + block, bi->pages_in_use, bi->has_shrink_hdr, + whole_block); - oh->isShrink = isShrink; + /*yaffs_verify_free_chunks(dev); */ - switch (in->variantType) { - case YAFFS_OBJECT_TYPE_UNKNOWN: - /* Should not happen */ - break; - case YAFFS_OBJECT_TYPE_FILE: - oh->fileSize = - (oh->parentObjectId == YAFFS_OBJECTID_DELETED - || oh->parentObjectId == - YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant. - fileVariant.fileSize; - break; - case YAFFS_OBJECT_TYPE_HARDLINK: - oh->equivalentObjectId = - in->variant.hardLinkVariant.equivalentObjectId; - break; - case YAFFS_OBJECT_TYPE_SPECIAL: - /* Do nothing */ - break; - case YAFFS_OBJECT_TYPE_DIRECTORY: - /* Do nothing */ - break; - case YAFFS_OBJECT_TYPE_SYMLINK: - yaffs_strncpy(oh->alias, - in->variant.symLinkVariant.alias, - YAFFS_MAX_ALIAS_LENGTH); - oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; - break; - } + if (bi->block_state == YAFFS_BLOCK_STATE_FULL) + bi->block_state = YAFFS_BLOCK_STATE_COLLECTING; - /* Tags */ - yaffs_InitialiseTags(&newTags); - in->serial++; - newTags.chunkId = 0; - newTags.objectId = in->objectId; - newTags.serialNumber = in->serial; + bi->has_shrink_hdr = 0; /* clear the flag so that the block can erase */ - /* Add extra info for file header */ + dev->gc_disable = 1; - newTags.extraHeaderInfoAvailable = 1; - newTags.extraParentObjectId = oh->parentObjectId; - newTags.extraFileLength = oh->fileSize; - newTags.extraIsShrinkHeader = oh->isShrink; - newTags.extraEquivalentObjectId = oh->equivalentObjectId; - newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0; - newTags.extraObjectType = in->variantType; + yaffs_summary_gc(dev, block); - yaffs_VerifyObjectHeader(in,oh,&newTags,1); + if (is_checkpt_block || !yaffs_still_some_chunks(dev, block)) { + yaffs_trace(YAFFS_TRACE_TRACING, + "Collecting block %d that has no chunks in use", + block); + yaffs_block_became_dirty(dev, block); + } else { - /* Create new chunk in NAND */ - newChunkId = - yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags, - (prevChunkId >= 0) ? 1 : 0); + u8 *buffer = yaffs_get_temp_buffer(dev); - if (newChunkId >= 0) { + yaffs_verify_blk(dev, bi, block); - in->chunkId = newChunkId; + max_copies = (whole_block) ? dev->param.chunks_per_block : 5; + old_chunk = block * dev->param.chunks_per_block + dev->gc_chunk; - if (prevChunkId >= 0) { - yaffs_DeleteChunk(dev, prevChunkId, 1, - __LINE__); + 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)) { + /* Page is in use and might need to be copied */ + max_copies--; + ret_val = yaffs_gc_process_chunk(dev, bi, + old_chunk, buffer); } + } + yaffs_release_temp_buffer(dev, buffer); + } - if(!yaffs_ObjectHasCachedWriteData(in)) - in->dirty = 0; + yaffs_verify_collected_blk(dev, bi, block); - /* If this was a shrink, then mark the block that the chunk lives on */ - if (isShrink) { - bi = yaffs_GetBlockInfo(in->myDev, - newChunkId /in->myDev-> nChunksPerBlock); - bi->hasShrinkHeader = 1; + 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 */ + struct yaffs_obj *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; + yaffs_trace(YAFFS_TRACE_GC, + "yaffs: About to finally delete object %d", + object->obj_id); + yaffs_generic_obj_del(object); + object->my_dev->n_deleted_files--; } } - - retVal = newChunkId; - + chunks_after = yaffs_get_erased_chunks(dev); + if (chunks_before >= chunks_after) + yaffs_trace(YAFFS_TRACE_GC, + "gc did not increase free chunks before %d after %d", + chunks_before, chunks_after); + dev->gc_block = 0; + dev->gc_chunk = 0; + dev->n_clean_ups = 0; } - if (buffer) - yaffs_ReleaseTempBuffer(dev, buffer, __LINE__); + dev->gc_disable = 0; - return retVal; + return ret_val; } -/*------------------------ Short Operations Cache ---------------------------------------- - * In many situations where there is no high level buffering (eg WinCE) a lot of - * reads might be short sequential reads, and a lot of writes may be short - * sequential writes. eg. scanning/writing a jpeg file. - * In these cases, a short read/write cache can provide a huge perfomance benefit - * with dumb-as-a-rock code. - * In Linux, the page cache provides read buffering aand the short op cache provides write - * buffering. - * - * There are a limited number (~10) of cache chunks per device so that we don't - * need a very intelligent search. +/* + * find_gc_block() selects the dirtiest block (or close enough) + * for garbage collection. */ -static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj) +static unsigned yaffs_find_gc_block(struct yaffs_dev *dev, + int aggressive, int background) { - yaffs_Device *dev = obj->myDev; int i; - yaffs_ChunkCache *cache; - int nCaches = obj->myDev->nShortOpCaches; - - for(i = 0; i < nCaches; i++){ - cache = &dev->srCache[i]; - if (cache->object == obj && - cache->dirty) - return 1; - } - - return 0; -} - + int iterations; + unsigned selected = 0; + int prioritised = 0; + int prioritised_exist = 0; + struct yaffs_block_info *bi; + int threshold; -static void yaffs_FlushFilesChunkCache(yaffs_Object * obj) -{ - yaffs_Device *dev = obj->myDev; - int lowest = -99; /* Stop compiler whining. */ - int i; - yaffs_ChunkCache *cache; - int chunkWritten = 0; - int nCaches = obj->myDev->nShortOpCaches; - - if (nCaches > 0) { - do { - cache = NULL; - - /* Find the dirty cache for this object with the lowest chunk id. */ - for (i = 0; i < nCaches; i++) { - if (dev->srCache[i].object == obj && - dev->srCache[i].dirty) { - if (!cache - || dev->srCache[i].chunkId < - lowest) { - cache = &dev->srCache[i]; - lowest = cache->chunkId; - } + /* 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; } } - - if (cache && !cache->locked) { - /* Write it out and free it up */ - - chunkWritten = - yaffs_WriteChunkDataToObject(cache->object, - cache->chunkId, - cache->data, - cache->nBytes, - 1); - cache->dirty = 0; - cache->object = NULL; - } - - } while (cache && chunkWritten > 0); - - if (cache) { - /* Hoosterman, disk full while writing cache out. */ - T(YAFFS_TRACE_ERROR, - (TSTR("yaffs tragedy: no space during cache write" TENDSTR))); - + 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. + */ -/*yaffs_FlushEntireDeviceCache(dev) - * - * - */ + if (prioritised_exist && + !selected && dev->oldest_dirty_block > 0) + selected = dev->oldest_dirty_block; -void yaffs_FlushEntireDeviceCache(yaffs_Device *dev) -{ - yaffs_Object *obj; - int nCaches = dev->nShortOpCaches; - int i; + if (!prioritised_exist) /* None found, so we can clear this */ + dev->has_pending_prioritised_gc = 0; + } - /* Find a dirty object in the cache and flush it... - * until there are no further dirty objects. + /* If we're doing aggressive GC then we are happy to take a less-dirty + * block, and search harder. + * else (leasurely gc), then we only bother to do this if the + * block has only a few pages in use. */ - do { - obj = NULL; - for( i = 0; i < nCaches && !obj; i++) { - if (dev->srCache[i].object && - dev->srCache[i].dirty) - obj = dev->srCache[i].object; - } - if(obj) - yaffs_FlushFilesChunkCache(obj); + 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; - } while(obj); + 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; -/* Grab us a cache chunk for use. - * First look for an empty one. - * Then look for the least recently used non-dirty one. - * Then look for the least recently used dirty one...., flush and look again. - */ -static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev) -{ - int i; - int usage; - int theOne; + iterations = n_blocks / 16 + 1; + if (iterations > 100) + iterations = 100; + } - if (dev->nShortOpCaches > 0) { - for (i = 0; i < dev->nShortOpCaches; i++) { - if (!dev->srCache[i].object) - return &dev->srCache[i]; + 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; + } } - return NULL; + if (dev->gc_dirtiest > 0 && dev->gc_pages_in_use <= threshold) + selected = dev->gc_dirtiest; + } - theOne = -1; - usage = 0; /* just to stop the compiler grizzling */ + /* + * If nothing has been selected for a while, try the oldest dirty + * because that's gumming up the works. + */ - for (i = 0; i < dev->nShortOpCaches; i++) { - if (!dev->srCache[i].dirty && - ((dev->srCache[i].lastUse < usage && theOne >= 0) || - theOne < 0)) { - usage = dev->srCache[i].lastUse; - theOne = i; - } + 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) { + yaffs_trace(YAFFS_TRACE_GC, + "GC Selected block %d with %d free, prioritised:%d", + selected, + dev->param.chunks_per_block - dev->gc_pages_in_use, + prioritised); + dev->n_gc_blocks++; + if (background) + dev->bg_gcs++; - return theOne >= 0 ? &dev->srCache[theOne] : NULL; + dev->gc_dirtiest = 0; + dev->gc_pages_in_use = 0; + dev->gc_not_done = 0; + if (dev->refresh_skip > 0) + dev->refresh_skip--; } else { - return NULL; + dev->gc_not_done++; + yaffs_trace(YAFFS_TRACE_GC, + "GC none: finder %d skip %d threshold %d dirtiest %d using %d oldest %d%s", + 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; } -static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device * dev) +/* 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 only accepts 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(struct yaffs_dev *dev, int background) { - yaffs_ChunkCache *cache; - yaffs_Object *theObj; - int usage; - int i; + int aggressive = 0; + int gc_ok = YAFFS_OK; + int max_tries = 0; + int min_erased; + int erased_chunks; + int checkpt_block_adjust; - if (dev->nShortOpCaches > 0) { - /* Try find a non-dirty one... */ + if (dev->param.gc_control && (dev->param.gc_control(dev) & 1) == 0) + return YAFFS_OK; - cache = yaffs_GrabChunkCacheWorker(dev); + if (dev->gc_disable) + /* Bail out so we don't get recursive gc */ + return YAFFS_OK; - if (!cache) { - /* They were all dirty, find the last recently used object and flush - * its cache, then find again. - * NB what's here is not very accurate, we actually flush the object - * the last recently used page. - */ + /* This loop should pass the first time. + * Only loops here if the collection does not increase space. + */ - /* With locking we can't assume we can use entry zero */ + do { + max_tries++; - theObj = NULL; - usage = -1; - cache = NULL; + checkpt_block_adjust = yaffs_calc_checkpt_blocks_required(dev); - for (i = 0; i < dev->nShortOpCaches; i++) { - if (dev->srCache[i].object && - !dev->srCache[i].locked && - (dev->srCache[i].lastUse < usage || !cache)) - { - usage = dev->srCache[i].lastUse; - theObj = dev->srCache[i].object; - cache = &dev->srCache[i]; - } - } + min_erased = + dev->param.n_reserved_blocks + checkpt_block_adjust + 1; + erased_chunks = + dev->n_erased_blocks * dev->param.chunks_per_block; - if (!cache || cache->dirty) { - /* Flush and try again */ - yaffs_FlushFilesChunkCache(theObj); - cache = yaffs_GrabChunkCacheWorker(dev); + /* 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; } - } - return cache; - } else - return NULL; -} + dev->gc_skip = 5; -/* Find a cached chunk */ -static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object * obj, - int chunkId) -{ - yaffs_Device *dev = obj->myDev; - int i; - if (dev->nShortOpCaches > 0) { - for (i = 0; i < dev->nShortOpCaches; i++) { - if (dev->srCache[i].object == obj && - dev->srCache[i].chunkId == chunkId) { - dev->cacheHits++; + /* If we don't already have a block being gc'd then see if we + * should start another */ - return &dev->srCache[i]; - } + if (dev->gc_block < 1 && !aggressive) { + dev->gc_block = yaffs2_find_refresh_block(dev); + dev->gc_chunk = 0; + dev->n_clean_ups = 0; } - } - return NULL; -} - -/* Mark the chunk for the least recently used algorithym */ -static void yaffs_UseChunkCache(yaffs_Device * dev, yaffs_ChunkCache * cache, - int isAWrite) -{ - - if (dev->nShortOpCaches > 0) { - if (dev->srLastUse < 0 || dev->srLastUse > 100000000) { - /* Reset the cache usages */ - int i; - for (i = 1; i < dev->nShortOpCaches; i++) { - dev->srCache[i].lastUse = 0; - } - dev->srLastUse = 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; } - dev->srLastUse++; + if (dev->gc_block > 0) { + dev->all_gcs++; + if (!aggressive) + dev->passive_gc_count++; - cache->lastUse = dev->srLastUse; + yaffs_trace(YAFFS_TRACE_GC, + "yaffs: GC n_erased_blocks %d aggressive %d", + dev->n_erased_blocks, aggressive); - if (isAWrite) { - cache->dirty = 1; + gc_ok = yaffs_gc_block(dev, dev->gc_block, aggressive); } - } -} - -/* Invalidate a single cache page. - * Do this when a whole page gets written, - * ie the short cache for this page is no longer valid. - */ -static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId) -{ - if (object->myDev->nShortOpCaches > 0) { - yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId); - if (cache) { - cache->object = NULL; + if (dev->n_erased_blocks < (dev->param.n_reserved_blocks) && + dev->gc_block > 0) { + yaffs_trace(YAFFS_TRACE_GC, + "yaffs: GC !!!no reclaim!!! n_erased_blocks %d after try %d block %d", + 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)); -/* Invalidate all the cache pages associated with this object - * Do this whenever ther file is deleted or resized. - */ -static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in) -{ - int i; - yaffs_Device *dev = in->myDev; - - if (dev->nShortOpCaches > 0) { - /* Invalidate it. */ - for (i = 0; i < dev->nShortOpCaches; i++) { - if (dev->srCache[i].object == in) { - dev->srCache[i].object = NULL; - } - } - } + return aggressive ? gc_ok : YAFFS_OK; } -/*--------------------- Checkpointing --------------------*/ - - -static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head) +/* + * 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(struct yaffs_dev *dev, unsigned urgency) { - yaffs_CheckpointValidity cp; + int erased_chunks = dev->n_erased_blocks * dev->param.chunks_per_block; - memset(&cp,0,sizeof(cp)); + yaffs_trace(YAFFS_TRACE_BACKGROUND, "Background gc %u", urgency); - cp.structType = sizeof(cp); - cp.magic = YAFFS_MAGIC; - cp.version = YAFFS_CHECKPOINT_VERSION; - cp.head = (head) ? 1 : 0; - - return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))? - 1 : 0; + yaffs_check_gc(dev, 1); + return erased_chunks > dev->n_free_chunks / 2; } -static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head) -{ - yaffs_CheckpointValidity cp; - int ok; - - ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp)); - - if(ok) - ok = (cp.structType == sizeof(cp)) && - (cp.magic == YAFFS_MAGIC) && - (cp.version == YAFFS_CHECKPOINT_VERSION) && - (cp.head == ((head) ? 1 : 0)); - return ok ? 1 : 0; -} +/*-------------------- Data file manipulation -----------------*/ -static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp, - yaffs_Device *dev) +static int yaffs_rd_data_obj(struct yaffs_obj *in, int inode_chunk, u8 * buffer) { - cp->nErasedBlocks = dev->nErasedBlocks; - cp->allocationBlock = dev->allocationBlock; - cp->allocationPage = dev->allocationPage; - cp->nFreeChunks = dev->nFreeChunks; + int nand_chunk = yaffs_find_chunk_in_file(in, inode_chunk, NULL); - cp->nDeletedFiles = dev->nDeletedFiles; - cp->nUnlinkedFiles = dev->nUnlinkedFiles; - cp->nBackgroundDeletions = dev->nBackgroundDeletions; - cp->sequenceNumber = dev->sequenceNumber; - cp->oldestDirtySequence = dev->oldestDirtySequence; + if (nand_chunk >= 0) + return yaffs_rd_chunk_tags_nand(in->my_dev, nand_chunk, + buffer, NULL); + else { + yaffs_trace(YAFFS_TRACE_NANDACCESS, + "Chunk %d not found zero instead", + nand_chunk); + /* get sane (zero) data if you read a hole */ + memset(buffer, 0, in->my_dev->data_bytes_per_chunk); + return 0; + } } -static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev, - yaffs_CheckpointDevice *cp) +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn) { - dev->nErasedBlocks = cp->nErasedBlocks; - dev->allocationBlock = cp->allocationBlock; - dev->allocationPage = cp->allocationPage; - dev->nFreeChunks = cp->nFreeChunks; + int block; + int page; + struct yaffs_ext_tags tags; + struct yaffs_block_info *bi; - dev->nDeletedFiles = cp->nDeletedFiles; - dev->nUnlinkedFiles = cp->nUnlinkedFiles; - dev->nBackgroundDeletions = cp->nBackgroundDeletions; - dev->sequenceNumber = cp->sequenceNumber; - dev->oldestDirtySequence = cp->oldestDirtySequence; -} + if (chunk_id <= 0) + return; + dev->n_deletions++; + block = chunk_id / dev->param.chunks_per_block; + page = chunk_id % dev->param.chunks_per_block; -static int yaffs_WriteCheckpointDevice(yaffs_Device *dev) -{ - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); + if (!yaffs_check_chunk_bit(dev, block, page)) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Deleting invalid chunk %d", chunk_id); - int ok; + bi = yaffs_get_block_info(dev, block); - /* Write device runtime values*/ - yaffs_DeviceToCheckpointDevice(&cp,dev); - cp.structType = sizeof(cp); + yaffs2_update_oldest_dirty_seq(dev, block, bi); - ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp)); + yaffs_trace(YAFFS_TRACE_DELETION, + "line %d delete of chunk %d", + lyn, chunk_id); - /* Write block info */ - if(ok) { - nBytes = nBlocks * sizeof(yaffs_BlockInfo); - ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes); - } + if (!dev->param.is_yaffs2 && mark_flash && + bi->block_state != YAFFS_BLOCK_STATE_COLLECTING) { - /* Write chunk bits */ - if(ok) { - nBytes = nBlocks * dev->chunkBitmapStride; - ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes); + memset(&tags, 0, sizeof(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++; } - return ok ? 1 : 0; + /* 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_SCAN || + 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_SCAN) { + yaffs_block_became_dirty(dev, block); + } + } } -static int yaffs_ReadCheckpointDevice(yaffs_Device *dev) +static int yaffs_wr_data_obj(struct yaffs_obj *in, int inode_chunk, + const u8 *buffer, int n_bytes, int use_reserve) { - yaffs_CheckpointDevice cp; - __u32 nBytes; - __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1); + /* Find old chunk Need to do this to get serial number + * Write new one and patch into tree. + * Invalidate old tags. + */ - int ok; + int prev_chunk_id; + struct yaffs_ext_tags prev_tags; + int new_chunk_id; + struct yaffs_ext_tags new_tags; + struct yaffs_dev *dev = in->my_dev; - ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp)); - if(!ok) - return 0; + yaffs_check_gc(dev, 0); - if(cp.structType != sizeof(cp)) + /* 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 */ + memset(&new_tags, 0, sizeof(new_tags)); - yaffs_CheckpointDeviceToDevice(dev,&cp); + 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; - nBytes = nBlocks * sizeof(yaffs_BlockInfo); + if (n_bytes < 1 || n_bytes > dev->param.total_bytes_per_chunk) { + yaffs_trace(YAFFS_TRACE_ERROR, + "Writing %d bytes to chunk!!!!!!!!!", + n_bytes); + BUG(); + } - ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes); + new_chunk_id = + yaffs_write_new_chunk(dev, buffer, &new_tags, use_reserve); - if(!ok) - return 0; - nBytes = nBlocks * dev->chunkBitmapStride; + if (new_chunk_id > 0) { + yaffs_put_chunk_in_file(in, inode_chunk, new_chunk_id, 0); - ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes); + if (prev_chunk_id > 0) + yaffs_chunk_del(dev, prev_chunk_id, 1, __LINE__); - return ok ? 1 : 0; -} + yaffs_verify_file_sane(in); + } + return new_chunk_id; -static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp, - yaffs_Object *obj) -{ +} - cp->objectId = obj->objectId; - cp->parentId = (obj->parent) ? obj->parent->objectId : 0; - cp->chunkId = obj->chunkId; - cp->variantType = obj->variantType; - cp->deleted = obj->deleted; - cp->softDeleted = obj->softDeleted; - cp->unlinked = obj->unlinked; - cp->fake = obj->fake; - cp->renameAllowed = obj->renameAllowed; - cp->unlinkAllowed = obj->unlinkAllowed; - cp->serial = obj->serial; - cp->nDataChunks = obj->nDataChunks; - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) - cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize; - else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId; -} -static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointObject *cp) +static int yaffs_do_xattrib_mod(struct yaffs_obj *obj, int set, + const YCHAR *name, const void *value, int size, + int flags) { + struct yaffs_xattr_mod xmod; + int result; - yaffs_Object *parent; + xmod.set = set; + xmod.name = name; + xmod.data = value; + xmod.size = size; + xmod.flags = flags; + xmod.result = -ENOSPC; - obj->objectId = cp->objectId; + result = yaffs_update_oh(obj, NULL, 0, 0, 0, &xmod); - if(cp->parentId) - parent = yaffs_FindOrCreateObjectByNumber( - obj->myDev, - cp->parentId, - YAFFS_OBJECT_TYPE_DIRECTORY); + if (result > 0) + return xmod.result; else - parent = NULL; - - if(parent) - yaffs_AddObjectToDirectory(parent, obj); - - obj->chunkId = cp->chunkId; - obj->variantType = cp->variantType; - obj->deleted = cp->deleted; - obj->softDeleted = cp->softDeleted; - obj->unlinked = cp->unlinked; - obj->fake = cp->fake; - obj->renameAllowed = cp->renameAllowed; - obj->unlinkAllowed = cp->unlinkAllowed; - obj->serial = cp->serial; - obj->nDataChunks = cp->nDataChunks; - - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) - obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId; - else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) - obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId; - - if(obj->objectId >= YAFFS_NOBJECT_BUCKETS) - obj->lazyLoaded = 1; + return -ENOSPC; } - - -static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn, - __u32 level, int chunkOffset) +static int yaffs_apply_xattrib_mod(struct yaffs_obj *obj, char *buffer, + struct yaffs_xattr_mod *xmod) { - int i; - yaffs_Device *dev = in->myDev; - int ok = 1; - int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8; - - if (tn) { - if (level > 0) { - - for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){ - if (tn->internal[i]) { - ok = yaffs_CheckpointTnodeWorker(in, - tn->internal[i], - level - 1, - (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i); - } - } - } else if (level == 0) { - __u32 baseOffset = chunkOffset << YAFFS_TNODES_LEVEL0_BITS; - /* printf("write tnode at %d\n",baseOffset); */ - ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset)); - if(ok) - ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes); - } - } + int retval = 0; + int x_offs = sizeof(struct yaffs_obj_hdr); + struct yaffs_dev *dev = obj->my_dev; + int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); + char *x_buffer = buffer + x_offs; - return ok; + if (xmod->set) + retval = + nval_set(x_buffer, x_size, xmod->name, xmod->data, + xmod->size, xmod->flags); + else + retval = nval_del(x_buffer, x_size, xmod->name); -} + obj->has_xattr = nval_hasvalues(x_buffer, x_size); + obj->xattr_known = 1; + xmod->result = retval; -static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj) -{ - __u32 endMarker = ~0; - int ok = 1; - - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){ - ok = yaffs_CheckpointTnodeWorker(obj, - obj->variant.fileVariant.top, - obj->variant.fileVariant.topLevel, - 0); - if(ok) - ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) == - sizeof(endMarker)); - } - - return ok ? 1 : 0; + return retval; } -static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj) +static int yaffs_do_xattrib_fetch(struct yaffs_obj *obj, const YCHAR *name, + void *value, int size) { - __u32 baseChunk; - int ok = 1; - yaffs_Device *dev = obj->myDev; - yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant; - yaffs_Tnode *tn; - int nread = 0; + char *buffer = NULL; + int result; + struct yaffs_ext_tags tags; + struct yaffs_dev *dev = obj->my_dev; + int x_offs = sizeof(struct yaffs_obj_hdr); + int x_size = dev->data_bytes_per_chunk - sizeof(struct yaffs_obj_hdr); + char *x_buffer; + int retval = 0; - ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk)); + if (obj->hdr_chunk < 1) + return -ENODATA; - while(ok && (~baseChunk)){ - nread++; - /* Read level 0 tnode */ + /* If we know that the object has no xattribs then don't do all the + * reading and parsing. + */ + if (obj->xattr_known && !obj->has_xattr) { + if (name) + return -ENODATA; + else + return 0; + } + buffer = (char *)yaffs_get_temp_buffer(dev); + if (!buffer) + return -ENOMEM; - /* printf("read tnode at %d\n",baseChunk); */ - tn = yaffs_GetTnodeRaw(dev); - if(tn) - ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) == - (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8); - else - ok = 0; + result = + yaffs_rd_chunk_tags_nand(dev, obj->hdr_chunk, (u8 *) buffer, &tags); - if(tn && ok){ - ok = yaffs_AddOrFindLevel0Tnode(dev, - fileStructPtr, - baseChunk, - tn) ? 1 : 0; + if (result != YAFFS_OK) + retval = -ENOENT; + else { + x_buffer = buffer + x_offs; + if (!obj->xattr_known) { + obj->has_xattr = nval_hasvalues(x_buffer, x_size); + obj->xattr_known = 1; } - if(ok) - ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk)); - + if (name) + retval = nval_get(x_buffer, x_size, name, value, size); + else + retval = nval_list(x_buffer, x_size, value, size); } - - T(YAFFS_TRACE_CHECKPOINT,( - TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR), - nread,baseChunk,ok)); - - return ok ? 1 : 0; + yaffs_release_temp_buffer(dev, (u8 *) buffer); + return retval; } - -static int yaffs_WriteCheckpointObjects(yaffs_Device *dev) +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR * name, + const void *value, int size, int flags) { - yaffs_Object *obj; - yaffs_CheckpointObject cp; - int i; - int ok = 1; - struct list_head *lh; - - - /* Iterate through the objects in each hash entry, - * dumping them to the checkpointing stream. - */ - - for(i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++){ - list_for_each(lh, &dev->objectBucket[i].list) { - if (lh) { - obj = list_entry(lh, yaffs_Object, hashLink); - if (!obj->deferedFree) { - yaffs_ObjectToCheckpointObject(&cp,obj); - cp.structType = sizeof(cp); - - T(YAFFS_TRACE_CHECKPOINT,( - TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR), - cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj)); - - ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp)); - - if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){ - ok = yaffs_WriteCheckpointTnodes(obj); - } - } - } - } - } - - /* Dump end of list */ - memset(&cp,0xFF,sizeof(yaffs_CheckpointObject)); - cp.structType = sizeof(cp); - - if(ok) - ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp)); - - return ok ? 1 : 0; + return yaffs_do_xattrib_mod(obj, 1, name, value, size, flags); } -static int yaffs_ReadCheckpointObjects(yaffs_Device *dev) +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR * name) { - yaffs_Object *obj; - yaffs_CheckpointObject cp; - int ok = 1; - int done = 0; - yaffs_Object *hardList = NULL; - - while(ok && !done) { - ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp)); - if(cp.structType != sizeof(cp)) { - T(YAFFS_TRACE_CHECKPOINT,(TSTR("struct size %d instead of %d ok %d"TENDSTR), - cp.structType,sizeof(cp),ok)); - ok = 0; - } - - T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR), - cp.objectId,cp.parentId,cp.variantType,cp.chunkId)); - - if(ok && cp.objectId == ~0) - done = 1; - else if(ok){ - obj = yaffs_FindOrCreateObjectByNumber(dev,cp.objectId, cp.variantType); - if(obj) { - yaffs_CheckpointObjectToObject(obj,&cp); - if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) { - ok = yaffs_ReadCheckpointTnodes(obj); - } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { - obj->hardLinks.next = - (struct list_head *) - hardList; - hardList = obj; - } - - } - } - } - - if(ok) - yaffs_HardlinkFixup(dev,hardList); - - return ok ? 1 : 0; + return yaffs_do_xattrib_mod(obj, 0, name, NULL, 0, 0); } -static int yaffs_WriteCheckpointSum(yaffs_Device *dev) +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR * name, void *value, + int size) { - __u32 checkpointSum; - int ok; - - yaffs_GetCheckpointSum(dev,&checkpointSum); - - ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum)); - - if(!ok) - return 0; - - return 1; + return yaffs_do_xattrib_fetch(obj, name, value, size); } -static int yaffs_ReadCheckpointSum(yaffs_Device *dev) +int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size) { - __u32 checkpointSum0; - __u32 checkpointSum1; - int ok; - - yaffs_GetCheckpointSum(dev,&checkpointSum0); - - ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1)); + return yaffs_do_xattrib_fetch(obj, NULL, buffer, size); +} - if(!ok) - return 0; +static void yaffs_check_obj_details_loaded(struct yaffs_obj *in) +{ + u8 *buf; + struct yaffs_obj_hdr *oh; + struct yaffs_dev *dev; + struct yaffs_ext_tags tags; + int result; + int alloc_failed = 0; - if(checkpointSum0 != checkpointSum1) - return 0; + if (!in || !in->lazy_loaded || in->hdr_chunk < 1) + return; - return 1; + dev = in->my_dev; + in->lazy_loaded = 0; + buf = yaffs_get_temp_buffer(dev); + + result = yaffs_rd_chunk_tags_nand(dev, in->hdr_chunk, buf, &tags); + oh = (struct yaffs_obj_hdr *)buf; + + in->yst_mode = oh->yst_mode; + yaffs_load_attribs(in, oh); + yaffs_set_obj_name_from_oh(in, oh); + + if (in->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + in->variant.symlink_variant.alias = + yaffs_clone_str(oh->alias); + if (!in->variant.symlink_variant.alias) + alloc_failed = 1; /* Not returned */ + } + yaffs_release_temp_buffer(dev, buf); +} + +static void yaffs_load_name_from_oh(struct yaffs_dev *dev, YCHAR *name, + const YCHAR *oh_name, int buff_size) +{ +#ifdef CONFIG_YAFFS_AUTO_UNICODE + if (dev->param.auto_unicode) { + if (*oh_name) { + /* It is an ASCII name, do an ASCII to + * unicode conversion */ + const char *ascii_oh_name = (const char *)oh_name; + int n = buff_size - 1; + while (n > 0 && *ascii_oh_name) { + *name = *ascii_oh_name; + name++; + ascii_oh_name++; + n--; + } + } else { + yaffs_strncpy(name, oh_name + 1, buff_size - 1); + } + } else { +#else + dev = dev; + { +#endif + yaffs_strncpy(name, oh_name, buff_size - 1); + } } - -static int yaffs_WriteCheckpointData(yaffs_Device *dev) +static void yaffs_load_oh_from_name(struct yaffs_dev *dev, YCHAR *oh_name, + const YCHAR *name) { +#ifdef CONFIG_YAFFS_AUTO_UNICODE - int ok = 1; + int is_ascii; + YCHAR *w; - if(dev->skipCheckpointWrite || !dev->isYaffs2){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR))); - ok = 0; - } + if (dev->param.auto_unicode) { - if(ok) - ok = yaffs_CheckpointOpen(dev,1); + is_ascii = 1; + w = name; - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR))); - ok = yaffs_WriteCheckpointValidityMarker(dev,1); - } - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint device" TENDSTR))); - ok = yaffs_WriteCheckpointDevice(dev); - } - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint objects" TENDSTR))); - ok = yaffs_WriteCheckpointObjects(dev); - } - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR))); - ok = yaffs_WriteCheckpointValidityMarker(dev,0); - } + /* Figure out if the name will fit in ascii character set */ + while (is_ascii && *w) { + if ((*w) & 0xff00) + is_ascii = 0; + w++; + } - if(ok){ - ok = yaffs_WriteCheckpointSum(dev); + if (is_ascii) { + /* It is an ASCII name, so convert unicode to ascii */ + char *ascii_oh_name = (char *)oh_name; + int n = YAFFS_MAX_NAME_LENGTH - 1; + while (n > 0 && *name) { + *ascii_oh_name = *name; + name++; + ascii_oh_name++; + n--; + } + } else { + /* Unicode name, so save starting at the second YCHAR */ + *oh_name = 0; + yaffs_strncpy(oh_name + 1, name, YAFFS_MAX_NAME_LENGTH - 2); + } + } else { +#else + dev = dev; + { +#endif + yaffs_strncpy(oh_name, name, YAFFS_MAX_NAME_LENGTH - 1); } +} +/* UpdateObjectHeader updates the header on NAND for an object. + * If name is not NULL, then that new name is used. + */ +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, int force, + int is_shrink, int shadows, struct yaffs_xattr_mod *xmod) +{ - if(!yaffs_CheckpointClose(dev)) - ok = 0; + struct yaffs_block_info *bi; + struct yaffs_dev *dev = in->my_dev; + int prev_chunk_id; + int ret_val = 0; + int result = 0; + int new_chunk_id; + struct yaffs_ext_tags new_tags; + struct yaffs_ext_tags old_tags; + const YCHAR *alias = NULL; + u8 *buffer = NULL; + YCHAR old_name[YAFFS_MAX_NAME_LENGTH + 1]; + struct yaffs_obj_hdr *oh = NULL; + loff_t file_size = 0; - if(ok) - dev->isCheckpointed = 1; - else - dev->isCheckpointed = 0; + yaffs_strcpy(old_name, _Y("silly old name")); - return dev->isCheckpointed; -} + if (in->fake && in != dev->root_dir && !force && !xmod) + return ret_val; -static int yaffs_ReadCheckpointData(yaffs_Device *dev) -{ - int ok = 1; + yaffs_check_gc(dev, 0); + yaffs_check_obj_details_loaded(in); - if(dev->skipCheckpointRead || !dev->isYaffs2){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR))); - ok = 0; - } + buffer = yaffs_get_temp_buffer(in->my_dev); + oh = (struct yaffs_obj_hdr *)buffer; - if(ok) - ok = yaffs_CheckpointOpen(dev,0); /* open for read */ + prev_chunk_id = in->hdr_chunk; - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs_ReadCheckpointValidityMarker(dev,1); - } - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint device" TENDSTR))); - ok = yaffs_ReadCheckpointDevice(dev); - } - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR))); - ok = yaffs_ReadCheckpointObjects(dev); - } - if(ok){ - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR))); - ok = yaffs_ReadCheckpointValidityMarker(dev,0); - } + if (prev_chunk_id > 0) { + result = yaffs_rd_chunk_tags_nand(dev, prev_chunk_id, + buffer, &old_tags); - if(ok){ - ok = yaffs_ReadCheckpointSum(dev); - T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok)); + yaffs_verify_oh(in, oh, &old_tags, 0); + memcpy(old_name, oh->name, sizeof(oh->name)); + memset(buffer, 0xff, sizeof(struct yaffs_obj_hdr)); + } else { + memset(buffer, 0xff, dev->data_bytes_per_chunk); } - if(!yaffs_CheckpointClose(dev)) - ok = 0; - - if(ok) - dev->isCheckpointed = 1; - else - dev->isCheckpointed = 0; + oh->type = in->variant_type; + oh->yst_mode = in->yst_mode; + oh->shadows_obj = oh->inband_shadowed_obj_id = shadows; - return ok ? 1 : 0; + yaffs_load_attribs_oh(oh, in); -} + if (in->parent) + oh->parent_obj_id = in->parent->obj_id; + else + oh->parent_obj_id = 0; -static void yaffs_InvalidateCheckpoint(yaffs_Device *dev) -{ - if(dev->isCheckpointed || - dev->blocksInCheckpoint > 0){ - dev->isCheckpointed = 0; - yaffs_CheckpointInvalidateStream(dev); - if(dev->superBlock && dev->markSuperBlockDirty) - dev->markSuperBlockDirty(dev->superBlock); + if (name && *name) { + memset(oh->name, 0, sizeof(oh->name)); + yaffs_load_oh_from_name(dev, oh->name, name); + } else if (prev_chunk_id > 0) { + memcpy(oh->name, old_name, sizeof(oh->name)); + } else { + memset(oh->name, 0, sizeof(oh->name)); } -} + oh->is_shrink = is_shrink; -int yaffs_CheckpointSave(yaffs_Device *dev) -{ - - T(YAFFS_TRACE_CHECKPOINT,(TSTR("save entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed)); + switch (in->variant_type) { + case YAFFS_OBJECT_TYPE_UNKNOWN: + /* Should not happen */ + break; + case YAFFS_OBJECT_TYPE_FILE: + if (oh->parent_obj_id != YAFFS_OBJECTID_DELETED && + oh->parent_obj_id != YAFFS_OBJECTID_UNLINKED) + file_size = in->variant.file_variant.file_size; + yaffs_oh_size_load(oh, file_size); + break; + case YAFFS_OBJECT_TYPE_HARDLINK: + oh->equiv_id = in->variant.hardlink_variant.equiv_id; + break; + case YAFFS_OBJECT_TYPE_SPECIAL: + /* Do nothing */ + break; + case YAFFS_OBJECT_TYPE_DIRECTORY: + /* Do nothing */ + break; + case YAFFS_OBJECT_TYPE_SYMLINK: + alias = in->variant.symlink_variant.alias; + if (!alias) + alias = _Y("no alias"); + yaffs_strncpy(oh->alias, alias, YAFFS_MAX_ALIAS_LENGTH); + oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0; + break; + } - yaffs_VerifyObjects(dev); - yaffs_VerifyBlocks(dev); - yaffs_VerifyFreeChunks(dev); + /* process any xattrib modifications */ + if (xmod) + yaffs_apply_xattrib_mod(in, (char *)buffer, xmod); + + /* Tags */ + memset(&new_tags, 0, sizeof(new_tags)); + in->serial++; + new_tags.chunk_id = 0; + new_tags.obj_id = in->obj_id; + new_tags.serial_number = in->serial; + + /* Add extra info for file header */ + new_tags.extra_available = 1; + new_tags.extra_parent_id = oh->parent_obj_id; + new_tags.extra_file_size = file_size; + new_tags.extra_is_shrink = oh->is_shrink; + new_tags.extra_equiv_id = oh->equiv_id; + new_tags.extra_shadows = (oh->shadows_obj > 0) ? 1 : 0; + new_tags.extra_obj_type = in->variant_type; + yaffs_verify_oh(in, oh, &new_tags, 1); + + /* Create new chunk in NAND */ + new_chunk_id = + yaffs_write_new_chunk(dev, buffer, &new_tags, + (prev_chunk_id > 0) ? 1 : 0); - if(!dev->isCheckpointed) { - yaffs_InvalidateCheckpoint(dev); - yaffs_WriteCheckpointData(dev); - } + if (buffer) + yaffs_release_temp_buffer(dev, buffer); - T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed)); + if (new_chunk_id < 0) + return new_chunk_id; - return dev->isCheckpointed; -} + in->hdr_chunk = new_chunk_id; -int yaffs_CheckpointRestore(yaffs_Device *dev) -{ - int retval; - T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed)); + if (prev_chunk_id > 0) + yaffs_chunk_del(dev, prev_chunk_id, 1, __LINE__); - retval = yaffs_ReadCheckpointData(dev); + if (!yaffs_obj_cache_dirty(in)) + in->dirty = 0; - if(dev->isCheckpointed){ - yaffs_VerifyObjects(dev); - yaffs_VerifyBlocks(dev); - yaffs_VerifyFreeChunks(dev); + /* If this was a shrink, then mark the block + * that the chunk lives on */ + if (is_shrink) { + bi = yaffs_get_block_info(in->my_dev, + new_chunk_id / + in->my_dev->param.chunks_per_block); + bi->has_shrink_hdr = 1; } - T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed)); - return retval; + return new_chunk_id; } /*--------------------- File read/write ------------------------ @@ -4447,622 +3432,550 @@ int yaffs_CheckpointRestore(yaffs_Device *dev) * Curve-balls: the first chunk might also be the last chunk. */ -int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset, - int nBytes) +int yaffs_file_rd(struct yaffs_obj *in, u8 * buffer, loff_t offset, int n_bytes) { + int chunk; + u32 start; + int n_copy; + int n = n_bytes; + int n_done = 0; + struct yaffs_cache *cache; + struct yaffs_dev *dev; - __u32 chunk = 0; - __u32 start = 0; - int nToCopy; - int n = nBytes; - int nDone = 0; - yaffs_ChunkCache *cache; - - yaffs_Device *dev; - - dev = in->myDev; + dev = in->my_dev; while (n > 0) { - //chunk = offset / dev->nDataBytesPerChunk + 1; - //start = offset % dev->nDataBytesPerChunk; - yaffs_AddrToChunk(dev,offset,&chunk,&start); + yaffs_addr_to_chunk(dev, offset, &chunk, &start); chunk++; /* OK now check for the curveball where the start and end are in * the same chunk. */ - if ((start + n) < dev->nDataBytesPerChunk) { - nToCopy = n; - } else { - nToCopy = dev->nDataBytesPerChunk - start; - } + if ((start + n) < dev->data_bytes_per_chunk) + n_copy = n; + else + n_copy = dev->data_bytes_per_chunk - start; - cache = yaffs_FindChunkCache(in, chunk); + cache = yaffs_find_chunk_cache(in, chunk); - /* If the chunk is already in the cache or it is less than a whole chunk - * then use the cache (if there is caching) - * else bypass the cache. + /* If the chunk is already in the cache or it is less than + * a whole chunk or we're using inband tags then use the cache + * (if there is caching) else bypass the cache. */ - if (cache || nToCopy != dev->nDataBytesPerChunk) { - if (dev->nShortOpCaches > 0) { + if (cache || n_copy != dev->data_bytes_per_chunk || + dev->param.inband_tags) { + if (dev->param.n_caches > 0) { - /* If we can't find the data in the cache, then load it up. */ + /* If we can't find the data in the cache, + * then load it up. */ if (!cache) { - cache = yaffs_GrabChunkCache(in->myDev); + cache = + yaffs_grab_chunk_cache(in->my_dev); cache->object = in; - cache->chunkId = chunk; + cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; - yaffs_ReadChunkDataFromObject(in, chunk, - cache-> - data); - cache->nBytes = 0; + yaffs_rd_data_obj(in, chunk, + cache->data); + cache->n_bytes = 0; } - yaffs_UseChunkCache(dev, cache, 0); + yaffs_use_cache(dev, cache, 0); cache->locked = 1; -#ifdef CONFIG_YAFFS_WINCE - yfsd_UnlockYAFFS(TRUE); -#endif - memcpy(buffer, &cache->data[start], nToCopy); + memcpy(buffer, &cache->data[start], n_copy); -#ifdef CONFIG_YAFFS_WINCE - yfsd_LockYAFFS(TRUE); -#endif cache->locked = 0; } else { - /* Read into the local buffer then copy..*/ - - __u8 *localBuffer = - yaffs_GetTempBuffer(dev, __LINE__); - yaffs_ReadChunkDataFromObject(in, chunk, - localBuffer); -#ifdef CONFIG_YAFFS_WINCE - yfsd_UnlockYAFFS(TRUE); -#endif - memcpy(buffer, &localBuffer[start], nToCopy); - -#ifdef CONFIG_YAFFS_WINCE - yfsd_LockYAFFS(TRUE); -#endif - yaffs_ReleaseTempBuffer(dev, localBuffer, - __LINE__); - } - - } else { -#ifdef CONFIG_YAFFS_WINCE - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); - - /* Under WinCE can't do direct transfer. Need to use a local buffer. - * This is because we otherwise screw up WinCE's memory mapper - */ - yaffs_ReadChunkDataFromObject(in, chunk, localBuffer); + /* Read into the local buffer then copy.. */ -#ifdef CONFIG_YAFFS_WINCE - yfsd_UnlockYAFFS(TRUE); -#endif - memcpy(buffer, localBuffer, dev->nDataBytesPerChunk); + u8 *local_buffer = + yaffs_get_temp_buffer(dev); + yaffs_rd_data_obj(in, chunk, local_buffer); -#ifdef CONFIG_YAFFS_WINCE - yfsd_LockYAFFS(TRUE); - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); -#endif + memcpy(buffer, &local_buffer[start], n_copy); -#else - /* A full chunk. Read directly into the supplied buffer. */ - yaffs_ReadChunkDataFromObject(in, chunk, buffer); -#endif + yaffs_release_temp_buffer(dev, local_buffer); + } + } else { + /* A full chunk. Read directly into the buffer. */ + yaffs_rd_data_obj(in, chunk, buffer); } - - n -= nToCopy; - offset += nToCopy; - buffer += nToCopy; - nDone += nToCopy; - + n -= n_copy; + offset += n_copy; + buffer += n_copy; + n_done += n_copy; } - - return nDone; + return n_done; } -int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset, - int nBytes, int writeThrough) +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, + int n_bytes, int write_through) { - __u32 chunk = 0; - __u32 start = 0; - int nToCopy; - int n = nBytes; - int nDone = 0; - int nToWriteBack; - int startOfWrite = offset; - int chunkWritten = 0; - int nBytesRead; - - yaffs_Device *dev; - - dev = in->myDev; - - while (n > 0 && chunkWritten >= 0) { - //chunk = offset / dev->nDataBytesPerChunk + 1; - //start = offset % dev->nDataBytesPerChunk; - yaffs_AddrToChunk(dev,offset,&chunk,&start); - chunk++; + int chunk; + u32 start; + int n_copy; + int n = n_bytes; + int n_done = 0; + int n_writeback; + loff_t start_write = offset; + int chunk_written = 0; + u32 n_bytes_read; + loff_t chunk_start; + struct yaffs_dev *dev; + + dev = in->my_dev; + + while (n > 0 && chunk_written >= 0) { + yaffs_addr_to_chunk(dev, offset, &chunk, &start); + + if (((loff_t)chunk) * + dev->data_bytes_per_chunk + start != offset || + start >= dev->data_bytes_per_chunk) { + yaffs_trace(YAFFS_TRACE_ERROR, + "AddrToChunk of offset %lld gives chunk %d start %d", + offset, chunk, start); + } + chunk++; /* File pos to chunk in file offset */ /* OK now check for the curveball where the start and end are in * the same chunk. */ - if ((start + n) < dev->nDataBytesPerChunk) { - nToCopy = n; + if ((start + n) < dev->data_bytes_per_chunk) { + n_copy = n; - /* Now folks, to calculate how many bytes to write back.... - * If we're overwriting and not writing to then end of file then - * we need to write back as much as was there before. + /* Now calculate how many bytes to write back.... + * If we're overwriting and not writing to then end of + * file then we need to write back as much as was there + * before. */ - nBytesRead = - in->variant.fileVariant.fileSize - - ((chunk - 1) * dev->nDataBytesPerChunk); + chunk_start = (((loff_t)(chunk - 1)) * + dev->data_bytes_per_chunk); - if (nBytesRead > dev->nDataBytesPerChunk) { - nBytesRead = dev->nDataBytesPerChunk; - } + if (chunk_start > in->variant.file_variant.file_size) + n_bytes_read = 0; /* Past end of file */ + else + n_bytes_read = + in->variant.file_variant.file_size - + chunk_start; + + if (n_bytes_read > dev->data_bytes_per_chunk) + n_bytes_read = dev->data_bytes_per_chunk; - nToWriteBack = - (nBytesRead > - (start + n)) ? nBytesRead : (start + n); + n_writeback = + (n_bytes_read > + (start + n)) ? n_bytes_read : (start + n); + + if (n_writeback < 0 || + n_writeback > dev->data_bytes_per_chunk) + BUG(); } else { - nToCopy = dev->nDataBytesPerChunk - start; - nToWriteBack = dev->nDataBytesPerChunk; + n_copy = dev->data_bytes_per_chunk - start; + n_writeback = dev->data_bytes_per_chunk; } - if (nToCopy != dev->nDataBytesPerChunk) { - /* An incomplete start or end chunk (or maybe both start and end chunk) */ - if (dev->nShortOpCaches > 0) { - yaffs_ChunkCache *cache; - /* If we can't find the data in the cache, then load the cache */ - cache = yaffs_FindChunkCache(in, chunk); - - if (!cache - && yaffs_CheckSpaceForAllocation(in-> - myDev)) { - cache = yaffs_GrabChunkCache(in->myDev); + if (n_copy != dev->data_bytes_per_chunk || + dev->param.inband_tags) { + /* An incomplete start or end chunk (or maybe both + * start and end chunk), or we're using inband tags, + * so we want to use the cache buffers. + */ + if (dev->param.n_caches > 0) { + struct yaffs_cache *cache; + + /* If we can't find the data in the cache, then + * load the cache */ + cache = yaffs_find_chunk_cache(in, chunk); + + if (!cache && + yaffs_check_alloc_available(dev, 1)) { + cache = yaffs_grab_chunk_cache(dev); cache->object = in; - cache->chunkId = chunk; + cache->chunk_id = chunk; cache->dirty = 0; cache->locked = 0; - yaffs_ReadChunkDataFromObject(in, chunk, - cache-> - data); - } - else if(cache && - !cache->dirty && - !yaffs_CheckSpaceForAllocation(in->myDev)){ - /* Drop the cache if it was a read cache item and - * no space check has been made for it. + yaffs_rd_data_obj(in, chunk, + cache->data); + } else if (cache && + !cache->dirty && + !yaffs_check_alloc_available(dev, + 1)) { + /* Drop the cache if it was a read cache + * item and no space check has been made + * for it. */ - cache = NULL; + cache = NULL; } if (cache) { - yaffs_UseChunkCache(dev, cache, 1); + yaffs_use_cache(dev, cache, 1); cache->locked = 1; -#ifdef CONFIG_YAFFS_WINCE - yfsd_UnlockYAFFS(TRUE); -#endif memcpy(&cache->data[start], buffer, - nToCopy); + n_copy); -#ifdef CONFIG_YAFFS_WINCE - yfsd_LockYAFFS(TRUE); -#endif cache->locked = 0; - cache->nBytes = nToWriteBack; + cache->n_bytes = n_writeback; - if (writeThrough) { - chunkWritten = - yaffs_WriteChunkDataToObject + if (write_through) { + chunk_written = + yaffs_wr_data_obj (cache->object, - cache->chunkId, - cache->data, cache->nBytes, - 1); + cache->chunk_id, + cache->data, + cache->n_bytes, 1); cache->dirty = 0; } - } else { - chunkWritten = -1; /* fail the write */ + chunk_written = -1; /* fail write */ } } else { - /* An incomplete start or end chunk (or maybe both start and end chunk) - * Read into the local buffer then copy, then copy over and write back. + /* An incomplete start or end chunk (or maybe + * both start and end chunk). Read into the + * local buffer then copy over and write back. */ - __u8 *localBuffer = - yaffs_GetTempBuffer(dev, __LINE__); + u8 *local_buffer = yaffs_get_temp_buffer(dev); - yaffs_ReadChunkDataFromObject(in, chunk, - localBuffer); + yaffs_rd_data_obj(in, chunk, local_buffer); + memcpy(&local_buffer[start], buffer, n_copy); -#ifdef CONFIG_YAFFS_WINCE - yfsd_UnlockYAFFS(TRUE); -#endif - - memcpy(&localBuffer[start], buffer, nToCopy); - -#ifdef CONFIG_YAFFS_WINCE - yfsd_LockYAFFS(TRUE); -#endif - chunkWritten = - yaffs_WriteChunkDataToObject(in, chunk, - localBuffer, - nToWriteBack, - 0); - - yaffs_ReleaseTempBuffer(dev, localBuffer, - __LINE__); + chunk_written = + yaffs_wr_data_obj(in, chunk, + local_buffer, + n_writeback, 0); + yaffs_release_temp_buffer(dev, local_buffer); } - } else { + /* A full chunk. Write directly from the buffer. */ -#ifdef CONFIG_YAFFS_WINCE - /* Under WinCE can't do direct transfer. Need to use a local buffer. - * This is because we otherwise screw up WinCE's memory mapper - */ - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); -#ifdef CONFIG_YAFFS_WINCE - yfsd_UnlockYAFFS(TRUE); -#endif - memcpy(localBuffer, buffer, dev->nDataBytesPerChunk); -#ifdef CONFIG_YAFFS_WINCE - yfsd_LockYAFFS(TRUE); -#endif - chunkWritten = - yaffs_WriteChunkDataToObject(in, chunk, localBuffer, - dev->nDataBytesPerChunk, - 0); - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); -#else - /* A full chunk. Write directly from the supplied buffer. */ - chunkWritten = - yaffs_WriteChunkDataToObject(in, chunk, buffer, - dev->nDataBytesPerChunk, - 0); -#endif - /* Since we've overwritten the cached data, we better invalidate it. */ - yaffs_InvalidateChunkCache(in, chunk); - } + chunk_written = + yaffs_wr_data_obj(in, chunk, buffer, + dev->data_bytes_per_chunk, 0); - if (chunkWritten >= 0) { - n -= nToCopy; - offset += nToCopy; - buffer += nToCopy; - nDone += nToCopy; + /* Since we've overwritten the cached data, + * we better invalidate it. */ + yaffs_invalidate_chunk_cache(in, chunk); } + if (chunk_written >= 0) { + n -= n_copy; + offset += n_copy; + buffer += n_copy; + n_done += n_copy; + } } /* Update file object */ - if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) { - in->variant.fileVariant.fileSize = (startOfWrite + nDone); - } + if ((start_write + n_done) > in->variant.file_variant.file_size) + in->variant.file_variant.file_size = (start_write + n_done); in->dirty = 1; - - return nDone; + return n_done; } +int yaffs_wr_file(struct yaffs_obj *in, const u8 *buffer, loff_t offset, + int n_bytes, int write_through) +{ + yaffs2_handle_hole(in, offset); + return yaffs_do_file_wr(in, buffer, offset, n_bytes, write_through); +} /* ---------------------- File resizing stuff ------------------ */ -static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize) +static void yaffs_prune_chunks(struct yaffs_obj *in, loff_t new_size) { - yaffs_Device *dev = in->myDev; - int oldFileSize = in->variant.fileVariant.fileSize; + struct yaffs_dev *dev = in->my_dev; + loff_t old_size = in->variant.file_variant.file_size; + int i; + int chunk_id; + u32 dummy; + int last_del; + int start_del; - int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk; + if (old_size > 0) + yaffs_addr_to_chunk(dev, old_size - 1, &last_del, &dummy); + else + last_del = 0; - int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) / - dev->nDataBytesPerChunk; - int i; - int chunkId; + yaffs_addr_to_chunk(dev, new_size + dev->data_bytes_per_chunk - 1, + &start_del, &dummy); + last_del++; + start_del++; /* Delete backwards so that we don't end up with holes if * power is lost part-way through the operation. */ - for (i = lastDel; i >= startDel; i--) { + for (i = last_del; i >= start_del; i--) { /* NB this could be optimised somewhat, * eg. could retrieve the tags and write them without - * using yaffs_DeleteChunk + * using yaffs_chunk_del */ - chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL); - if (chunkId > 0) { - if (chunkId < - (dev->internalStartBlock * dev->nChunksPerBlock) - || chunkId >= - ((dev->internalEndBlock + - 1) * dev->nChunksPerBlock)) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("Found daft chunkId %d for %d" TENDSTR), - chunkId, i)); - } else { - in->nDataChunks--; - yaffs_DeleteChunk(dev, chunkId, 1, __LINE__); - } + chunk_id = yaffs_find_del_file_chunk(in, i, NULL); + + if (chunk_id < 1) + continue; + + if (chunk_id < + (dev->internal_start_block * dev->param.chunks_per_block) || + chunk_id >= + ((dev->internal_end_block + 1) * + dev->param.chunks_per_block)) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "Found daft chunk_id %d for %d", + chunk_id, i); + } else { + in->n_data_chunks--; + yaffs_chunk_del(dev, chunk_id, 1, __LINE__); } } - } -int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize) +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size) { + int new_full; + u32 new_partial; + struct yaffs_dev *dev = obj->my_dev; - int oldFileSize = in->variant.fileVariant.fileSize; - __u32 newSizeOfPartialChunk = 0; - __u32 newFullChunks = 0; + yaffs_addr_to_chunk(dev, new_size, &new_full, &new_partial); - yaffs_Device *dev = in->myDev; + yaffs_prune_chunks(obj, new_size); - yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk); + if (new_partial != 0) { + int last_chunk = 1 + new_full; + u8 *local_buffer = yaffs_get_temp_buffer(dev); - yaffs_FlushFilesChunkCache(in); - yaffs_InvalidateWholeChunkCache(in); + /* Rewrite the last chunk with its new size and zero pad */ + yaffs_rd_data_obj(obj, last_chunk, local_buffer); + memset(local_buffer + new_partial, 0, + dev->data_bytes_per_chunk - new_partial); - yaffs_CheckGarbageCollection(dev); + yaffs_wr_data_obj(obj, last_chunk, local_buffer, + new_partial, 1); - if (in->variantType != YAFFS_OBJECT_TYPE_FILE) { - return yaffs_GetFileSize(in); + yaffs_release_temp_buffer(dev, local_buffer); } - if (newSize == oldFileSize) { - return oldFileSize; - } - - if (newSize < oldFileSize) { - - yaffs_PruneResizedChunks(in, newSize); - - if (newSizeOfPartialChunk != 0) { - int lastChunk = 1 + newFullChunks; + obj->variant.file_variant.file_size = new_size; - __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__); + yaffs_prune_tree(dev, &obj->variant.file_variant); +} - /* Got to read and rewrite the last chunk with its new size and zero pad */ - yaffs_ReadChunkDataFromObject(in, lastChunk, - localBuffer); +int yaffs_resize_file(struct yaffs_obj *in, loff_t new_size) +{ + struct yaffs_dev *dev = in->my_dev; + loff_t old_size = in->variant.file_variant.file_size; - memset(localBuffer + newSizeOfPartialChunk, 0, - dev->nDataBytesPerChunk - newSizeOfPartialChunk); + yaffs_flush_file_cache(in); + yaffs_invalidate_whole_cache(in); - yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer, - newSizeOfPartialChunk, 1); + yaffs_check_gc(dev, 0); - yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__); - } + if (in->variant_type != YAFFS_OBJECT_TYPE_FILE) + return YAFFS_FAIL; - in->variant.fileVariant.fileSize = newSize; + if (new_size == old_size) + return YAFFS_OK; - yaffs_PruneFileStructure(dev, &in->variant.fileVariant); + if (new_size > old_size) { + yaffs2_handle_hole(in, new_size); + in->variant.file_variant.file_size = new_size; } else { - /* newsSize > oldFileSize */ - in->variant.fileVariant.fileSize = newSize; + /* new_size < old_size */ + yaffs_resize_file_down(in, new_size); } - - - /* Write a new object header. + /* Write a new object header to reflect the resize. * show we've shrunk the file, if need be - * Do this only if the file is not in the deleted directories. + * Do this only if the file is not in the deleted directories + * and is not shadowed. */ - if (in->parent->objectId != YAFFS_OBJECTID_UNLINKED && - in->parent->objectId != YAFFS_OBJECTID_DELETED) { - yaffs_UpdateObjectHeader(in, NULL, 0, - (newSize < oldFileSize) ? 1 : 0, 0); - } + if (in->parent && + !in->is_shadowed && + in->parent->obj_id != YAFFS_OBJECTID_UNLINKED && + in->parent->obj_id != YAFFS_OBJECTID_DELETED) + yaffs_update_oh(in, NULL, 0, 0, 0, NULL); return YAFFS_OK; } -loff_t yaffs_GetFileSize(yaffs_Object * obj) -{ - obj = yaffs_GetEquivalentObject(obj); - - switch (obj->variantType) { - case YAFFS_OBJECT_TYPE_FILE: - return obj->variant.fileVariant.fileSize; - case YAFFS_OBJECT_TYPE_SYMLINK: - return yaffs_strlen(obj->variant.symLinkVariant.alias); - default: - return 0; - } -} - - - -int yaffs_FlushFile(yaffs_Object * in, int updateTime) +int yaffs_flush_file(struct yaffs_obj *in, int update_time, int data_sync) { - int retVal; - if (in->dirty) { - yaffs_FlushFilesChunkCache(in); - if (updateTime) { -#ifdef CONFIG_YAFFS_WINCE - yfsd_WinFileTimeNow(in->win_mtime); -#else + if (!in->dirty) + return YAFFS_OK; - in->yst_mtime = Y_CURRENT_TIME; + yaffs_flush_file_cache(in); -#endif - } - - retVal = - (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >= - 0) ? YAFFS_OK : YAFFS_FAIL; - } else { - retVal = YAFFS_OK; - } + if (data_sync) + return YAFFS_OK; - return retVal; + if (update_time) + yaffs_load_current_time(in, 0, 0); + return (yaffs_update_oh(in, NULL, 0, 0, 0, NULL) >= 0) ? + YAFFS_OK : YAFFS_FAIL; } -static int yaffs_DoGenericObjectDeletion(yaffs_Object * in) -{ - - /* First off, invalidate the file's data in the cache, without flushing. */ - yaffs_InvalidateWholeChunkCache(in); - if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) { - /* Move to the unlinked directory so we have a record that it was deleted. */ - yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0); - - } - - yaffs_RemoveObjectFromDirectory(in); - yaffs_DeleteChunk(in->myDev, in->chunkId, 1, __LINE__); - in->chunkId = -1; - - yaffs_FreeObject(in); - return YAFFS_OK; - -} - -/* yaffs_DeleteFile deletes the whole file data +/* yaffs_del_file deletes the whole file data * and the inode associated with the file. * It does not delete the links associated with the file. */ -static int yaffs_UnlinkFile(yaffs_Object * in) -{ - - int retVal; - int immediateDeletion = 0; - - if (1) { -/* XXX U-BOOT XXX */ -#if 0 -#ifdef __KERNEL__ - if (!in->myInode) { - immediateDeletion = 1; - - } -#endif -#else - if (in->inUse <= 0) { - immediateDeletion = 1; - - } -#endif - if (immediateDeletion) { - retVal = - yaffs_ChangeObjectName(in, in->myDev->deletedDir, - "deleted", 0, 0); - T(YAFFS_TRACE_TRACING, - (TSTR("yaffs: immediate deletion of file %d" TENDSTR), - in->objectId)); - in->deleted = 1; - in->myDev->nDeletedFiles++; - if (0 && in->myDev->isYaffs2) { - yaffs_ResizeFile(in, 0); - } - yaffs_SoftDeleteFile(in); - } else { - retVal = - yaffs_ChangeObjectName(in, in->myDev->unlinkedDir, - "unlinked", 0, 0); - } - +static int yaffs_unlink_file_if_needed(struct yaffs_obj *in) +{ + int ret_val; + int del_now = 0; + struct yaffs_dev *dev = in->my_dev; + + if (!in->my_inode) + del_now = 1; + + if (del_now) { + ret_val = + yaffs_change_obj_name(in, in->my_dev->del_dir, + _Y("deleted"), 0, 0); + yaffs_trace(YAFFS_TRACE_TRACING, + "yaffs: immediate deletion of file %d", + in->obj_id); + in->deleted = 1; + in->my_dev->n_deleted_files++; + if (dev->param.disable_soft_del || dev->param.is_yaffs2) + yaffs_resize_file(in, 0); + yaffs_soft_del_file(in); + } else { + ret_val = + yaffs_change_obj_name(in, in->my_dev->unlinked_dir, + _Y("unlinked"), 0, 0); } - return retVal; + return ret_val; } -int yaffs_DeleteFile(yaffs_Object * in) +int yaffs_del_file(struct yaffs_obj *in) { - int retVal = YAFFS_OK; + int ret_val = YAFFS_OK; + int deleted; /* Need to cache value on stack if in is freed */ + struct yaffs_dev *dev = in->my_dev; - if (in->nDataChunks > 0) { - /* Use soft deletion if there is data in the file */ - if (!in->unlinked) { - retVal = yaffs_UnlinkFile(in); - } - if (retVal == YAFFS_OK && in->unlinked && !in->deleted) { + if (dev->param.disable_soft_del || dev->param.is_yaffs2) + yaffs_resize_file(in, 0); + + if (in->n_data_chunks > 0) { + /* Use soft deletion if there is data in the file. + * That won't be the case if it has been resized to zero. + */ + if (!in->unlinked) + ret_val = yaffs_unlink_file_if_needed(in); + + deleted = in->deleted; + + if (ret_val == YAFFS_OK && in->unlinked && !in->deleted) { in->deleted = 1; - in->myDev->nDeletedFiles++; - yaffs_SoftDeleteFile(in); + deleted = 1; + in->my_dev->n_deleted_files++; + yaffs_soft_del_file(in); } - return in->deleted ? YAFFS_OK : YAFFS_FAIL; + return deleted ? YAFFS_OK : YAFFS_FAIL; } else { /* The file has no data chunks so we toss it immediately */ - yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top); - in->variant.fileVariant.top = NULL; - yaffs_DoGenericObjectDeletion(in); + yaffs_free_tnode(in->my_dev, in->variant.file_variant.top); + in->variant.file_variant.top = NULL; + yaffs_generic_obj_del(in); return YAFFS_OK; } } -static int yaffs_DeleteDirectory(yaffs_Object * in) +int yaffs_is_non_empty_dir(struct yaffs_obj *obj) { - /* First check that the directory is empty. */ - if (list_empty(&in->variant.directoryVariant.children)) { - return yaffs_DoGenericObjectDeletion(in); - } + return (obj && + obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) && + !(list_empty(&obj->variant.dir_variant.children)); +} - return YAFFS_FAIL; +static int yaffs_del_dir(struct yaffs_obj *obj) +{ + /* First check that the directory is empty. */ + if (yaffs_is_non_empty_dir(obj)) + return YAFFS_FAIL; + return yaffs_generic_obj_del(obj); } -static int yaffs_DeleteSymLink(yaffs_Object * in) +static int yaffs_del_symlink(struct yaffs_obj *in) { - YFREE(in->variant.symLinkVariant.alias); + kfree(in->variant.symlink_variant.alias); + in->variant.symlink_variant.alias = NULL; - return yaffs_DoGenericObjectDeletion(in); + return yaffs_generic_obj_del(in); } -static int yaffs_DeleteHardLink(yaffs_Object * in) +static int yaffs_del_link(struct yaffs_obj *in) { - /* remove this hardlink from the list assocaited with the equivalent + /* remove this hardlink from the list associated with the equivalent * object */ - list_del(&in->hardLinks); - return yaffs_DoGenericObjectDeletion(in); + list_del_init(&in->hard_links); + return yaffs_generic_obj_del(in); } -static void yaffs_DestroyObject(yaffs_Object * obj) +int yaffs_del_obj(struct yaffs_obj *obj) { - switch (obj->variantType) { + int ret_val = -1; + + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: - yaffs_DeleteFile(obj); + ret_val = yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - yaffs_DeleteDirectory(obj); + if (!list_empty(&obj->variant.dir_variant.dirty)) { + yaffs_trace(YAFFS_TRACE_BACKGROUND, + "Remove object %d from dirty directories", + obj->obj_id); + list_del_init(&obj->variant.dir_variant.dirty); + } + return yaffs_del_dir(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: - yaffs_DeleteSymLink(obj); + ret_val = yaffs_del_symlink(obj); break; case YAFFS_OBJECT_TYPE_HARDLINK: - yaffs_DeleteHardLink(obj); + ret_val = yaffs_del_link(obj); break; case YAFFS_OBJECT_TYPE_SPECIAL: - yaffs_DoGenericObjectDeletion(obj); + ret_val = yaffs_generic_obj_del(obj); break; case YAFFS_OBJECT_TYPE_UNKNOWN: + ret_val = 0; break; /* should not happen. */ } + return ret_val; } -static int yaffs_UnlinkWorker(yaffs_Object * obj) +static int yaffs_unlink_worker(struct yaffs_obj *obj) { + int del_now = 0; + + if (!obj) + return YAFFS_FAIL; - if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { - return yaffs_DeleteHardLink(obj); - } else if (!list_empty(&obj->hardLinks)) { + if (!obj->my_inode) + del_now = 1; + + yaffs_update_parent(obj->parent); + + if (obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { + return yaffs_del_link(obj); + } else if (!list_empty(&obj->hard_links)) { /* Curve ball: We're unlinking an object that has a hardlink. * * This problem arises because we are not strictly following @@ -5072,1638 +3985,532 @@ static int yaffs_UnlinkWorker(yaffs_Object * obj) * Instead, we do the following: * - Select a hardlink. * - Unhook it from the hard links - * - Unhook it from its parent directory (so that the rename can work) + * - Move it from its parent directory so that the rename works. * - Rename the object to the hardlink's name. * - Delete the hardlink */ - yaffs_Object *hl; - int retVal; + struct yaffs_obj *hl; + struct yaffs_obj *parent; + int ret_val; YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; - hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks); + hl = list_entry(obj->hard_links.next, struct yaffs_obj, + hard_links); - list_del_init(&hl->hardLinks); - list_del_init(&hl->siblings); + yaffs_get_obj_name(hl, name, YAFFS_MAX_NAME_LENGTH + 1); + parent = hl->parent; - yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1); + list_del_init(&hl->hard_links); - retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0); + yaffs_add_obj_to_dir(obj->my_dev->unlinked_dir, hl); - if (retVal == YAFFS_OK) { - retVal = yaffs_DoGenericObjectDeletion(hl); - } - return retVal; + ret_val = yaffs_change_obj_name(obj, parent, name, 0, 0); - } else { - switch (obj->variantType) { + if (ret_val == YAFFS_OK) + ret_val = yaffs_generic_obj_del(hl); + + return ret_val; + + } else if (del_now) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: - return yaffs_UnlinkFile(obj); + return yaffs_del_file(obj); break; case YAFFS_OBJECT_TYPE_DIRECTORY: - return yaffs_DeleteDirectory(obj); + list_del_init(&obj->variant.dir_variant.dirty); + return yaffs_del_dir(obj); break; case YAFFS_OBJECT_TYPE_SYMLINK: - return yaffs_DeleteSymLink(obj); + return yaffs_del_symlink(obj); break; case YAFFS_OBJECT_TYPE_SPECIAL: - return yaffs_DoGenericObjectDeletion(obj); + return yaffs_generic_obj_del(obj); break; case YAFFS_OBJECT_TYPE_HARDLINK: case YAFFS_OBJECT_TYPE_UNKNOWN: default: return YAFFS_FAIL; } + } else if (yaffs_is_non_empty_dir(obj)) { + return YAFFS_FAIL; + } else { + return yaffs_change_obj_name(obj, obj->my_dev->unlinked_dir, + _Y("unlinked"), 0, 0); } } - -static int yaffs_UnlinkObject( yaffs_Object *obj) +static int yaffs_unlink_obj(struct yaffs_obj *obj) { - - if (obj && obj->unlinkAllowed) { - return yaffs_UnlinkWorker(obj); - } + if (obj && obj->unlink_allowed) + return yaffs_unlink_worker(obj); return YAFFS_FAIL; +} + +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR *name) +{ + struct yaffs_obj *obj; + obj = yaffs_find_by_name(dir, name); + return yaffs_unlink_obj(obj); } -int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name) + +/* Note: + * If old_name is NULL then we take old_dir as the object to be renamed. + */ +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR *old_name, + struct yaffs_obj *new_dir, const YCHAR *new_name) { - yaffs_Object *obj; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *existing_target = NULL; + int force = 0; + int result; + struct yaffs_dev *dev; + + if (!old_dir || old_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + BUG(); + return YAFFS_FAIL; + } + if (!new_dir || new_dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + BUG(); + return YAFFS_FAIL; + } + + dev = old_dir->my_dev; + +#ifdef CONFIG_YAFFS_CASE_INSENSITIVE + /* Special case for case insemsitive systems. + * While look-up is case insensitive, the name isn't. + * Therefore we might want to change x.txt to X.txt + */ + if (old_dir == new_dir && + old_name && new_name && + 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; + + if (old_name) + obj = yaffs_find_by_name(old_dir, old_name); + else{ + obj = old_dir; + old_dir = obj->parent; + } + + if (obj && obj->rename_allowed) { + /* Now handle an existing target, if there is one */ + existing_target = yaffs_find_by_name(new_dir, new_name); + if (yaffs_is_non_empty_dir(existing_target)) { + return YAFFS_FAIL; /* 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 here 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); - obj = yaffs_FindObjectByName(dir, name); - return yaffs_UnlinkObject(obj); + return result; + } + return YAFFS_FAIL; } /*----------------------- Initialisation Scanning ---------------------- */ -static void yaffs_HandleShadowedObject(yaffs_Device * dev, int objId, - int backwardScanning) +void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, + int backward_scanning) { - yaffs_Object *obj; + struct yaffs_obj *obj; - if (!backwardScanning) { - /* Handle YAFFS1 forward scanning case - * For YAFFS1 we always do the deletion - */ - - } else { + if (backward_scanning) { /* Handle YAFFS2 case (backward scanning) * If the shadowed object exists then ignore. */ - if (yaffs_FindObjectByNumber(dev, objId)) { + obj = yaffs_find_by_number(dev, obj_id); + if (obj) return; - } } - /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc. + /* Let's create it (if it does not exist) assuming it is a file so that + * it can do shrinking etc. * We put it in unlinked dir to be cleaned up after the scanning */ obj = - yaffs_FindOrCreateObjectByNumber(dev, objId, - YAFFS_OBJECT_TYPE_FILE); - yaffs_AddObjectToDirectory(dev->unlinkedDir, obj); - obj->variant.fileVariant.shrinkSize = 0; - obj->valid = 1; /* So that we don't read any other info for this file */ - + yaffs_find_or_create_by_number(dev, obj_id, YAFFS_OBJECT_TYPE_FILE); + if (!obj) + return; + obj->is_shadowed = 1; + yaffs_add_obj_to_dir(dev->unlinked_dir, obj); + obj->variant.file_variant.shrink_size = 0; + obj->valid = 1; /* So that we don't read any other info. */ } -typedef struct { - int seq; - int block; -} yaffs_BlockIndex; - - -static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList) +void yaffs_link_fixup(struct yaffs_dev *dev, struct list_head *hard_list) { - yaffs_Object *hl; - yaffs_Object *in; - - while (hardList) { - hl = hardList; - hardList = (yaffs_Object *) (hardList->hardLinks.next); + struct list_head *lh; + struct list_head *save; + struct yaffs_obj *hl; + struct yaffs_obj *in; - in = yaffs_FindObjectByNumber(dev, - hl->variant.hardLinkVariant. - equivalentObjectId); + list_for_each_safe(lh, save, hard_list) { + hl = list_entry(lh, struct yaffs_obj, hard_links); + in = yaffs_find_by_number(dev, + hl->variant.hardlink_variant.equiv_id); if (in) { /* Add the hardlink pointers */ - hl->variant.hardLinkVariant.equivalentObject = in; - list_add(&hl->hardLinks, &in->hardLinks); + hl->variant.hardlink_variant.equiv_obj = in; + list_add(&hl->hard_links, &in->hard_links); } else { /* Todo Need to report/handle this better. * Got a problem... hardlink to a non-existant object */ - hl->variant.hardLinkVariant.equivalentObject = NULL; - INIT_LIST_HEAD(&hl->hardLinks); - + hl->variant.hardlink_variant.equiv_obj = NULL; + INIT_LIST_HEAD(&hl->hard_links); } - } - } - - - - -static int ybicmp(const void *a, const void *b){ - register int aseq = ((yaffs_BlockIndex *)a)->seq; - register int bseq = ((yaffs_BlockIndex *)b)->seq; - register int ablock = ((yaffs_BlockIndex *)a)->block; - register int bblock = ((yaffs_BlockIndex *)b)->block; - if( aseq == bseq ) - return ablock - bblock; - else - return aseq - bseq; - -} - -static int yaffs_Scan(yaffs_Device * dev) +static void yaffs_strip_deleted_objs(struct yaffs_dev *dev) { - yaffs_ExtendedTags tags; - int blk; - int blockIterator; - int startIterator; - int endIterator; - int nBlocksToScan = 0; - - int chunk; - int c; - int deleted; - yaffs_BlockState state; - yaffs_Object *hardList = NULL; - yaffs_BlockInfo *bi; - int sequenceNumber; - yaffs_ObjectHeader *oh; - yaffs_Object *in; - yaffs_Object *parent; - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; - - int alloc_failed = 0; - - - __u8 *chunkData; - - yaffs_BlockIndex *blockIndex = NULL; - - if (dev->isYaffs2) { - T(YAFFS_TRACE_SCAN, - (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR))); - return YAFFS_FAIL; - } - - //TODO Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format. - - T(YAFFS_TRACE_SCAN, - (TSTR("yaffs_Scan starts intstartblk %d intendblk %d..." TENDSTR), - dev->internalStartBlock, dev->internalEndBlock)); - - chunkData = yaffs_GetTempBuffer(dev, __LINE__); - - dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; - - if (dev->isYaffs2) { - blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex)); - if(!blockIndex) - return YAFFS_FAIL; - } - - /* Scan all the blocks to determine their state */ - for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { - bi = yaffs_GetBlockInfo(dev, blk); - yaffs_ClearChunkBits(dev, blk); - bi->pagesInUse = 0; - bi->softDeletions = 0; - - yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); - - bi->blockState = state; - bi->sequenceNumber = sequenceNumber; - - T(YAFFS_TRACE_SCAN_DEBUG, - (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, - state, sequenceNumber)); - - 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->nErasedBlocks++; - dev->nFreeChunks += dev->nChunksPerBlock; - } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - - /* Determine the highest sequence number */ - if (dev->isYaffs2 && - sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER && - sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) { - - blockIndex[nBlocksToScan].seq = sequenceNumber; - blockIndex[nBlocksToScan].block = blk; - - nBlocksToScan++; - - if (sequenceNumber >= dev->sequenceNumber) { - dev->sequenceNumber = sequenceNumber; - } - } else if (dev->isYaffs2) { - /* TODO: Nasty sequence number! */ - T(YAFFS_TRACE_SCAN, - (TSTR - ("Block scanning block %d has bad sequence number %d" - TENDSTR), blk, sequenceNumber)); - - } - } - } - - /* Sort the blocks - * Dungy old bubble sort for now... - */ - if (dev->isYaffs2) { - yaffs_BlockIndex temp; - int i; - int j; - - for (i = 0; i < nBlocksToScan; i++) - for (j = i + 1; j < nBlocksToScan; j++) - if (blockIndex[i].seq > blockIndex[j].seq) { - temp = blockIndex[j]; - blockIndex[j] = blockIndex[i]; - blockIndex[i] = temp; - } - } - - /* Now scan the blocks looking at the data. */ - if (dev->isYaffs2) { - startIterator = 0; - endIterator = nBlocksToScan - 1; - T(YAFFS_TRACE_SCAN_DEBUG, - (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan)); - } else { - startIterator = dev->internalStartBlock; - endIterator = dev->internalEndBlock; - } - - /* For each block.... */ - for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator; - blockIterator++) { - - if (dev->isYaffs2) { - /* get the block to scan in the correct order */ - blk = blockIndex[blockIterator].block; - } else { - blk = blockIterator; - } - - bi = yaffs_GetBlockInfo(dev, blk); - state = bi->blockState; - - deleted = 0; - - /* For each chunk in each block that needs scanning....*/ - for (c = 0; !alloc_failed && c < dev->nChunksPerBlock && - state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) { - /* Read the tags and decide what to do */ - chunk = blk * dev->nChunksPerBlock + c; - - yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, - &tags); - - /* Let's have a good look at this chunk... */ - - if (!dev->isYaffs2 && tags.chunkDeleted) { - /* YAFFS1 only... - * A deleted chunk - */ - deleted++; - dev->nFreeChunks++; - /*T((" %d %d deleted\n",blk,c)); */ - } else if (!tags.chunkUsed) { - /* 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->nErasedBlocks++; - } 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->allocationBlock = blk; - dev->allocationPage = c; - dev->allocationBlockFinder = blk; - /* Set it to here to encourage the allocator to go forth from here. */ - - /* Yaffs2 sanity check: - * This should be the one with the highest sequence number - */ - if (dev->isYaffs2 - && (dev->sequenceNumber != - bi->sequenceNumber)) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("yaffs: Allocation block %d was not highest sequence id:" - " block seq = %d, dev seq = %d" - TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber)); - } - } - - dev->nFreeChunks += (dev->nChunksPerBlock - c); - } else if (tags.chunkId > 0) { - /* chunkId > 0 so it is a data chunk... */ - unsigned int endpos; - - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; - - in = yaffs_FindOrCreateObjectByNumber(dev, - tags. - objectId, - YAFFS_OBJECT_TYPE_FILE); - /* PutChunkIntoFile checks for a clash (two data chunks with - * the same chunkId). - */ - - if(!in) - alloc_failed = 1; - - if(in){ - if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1)) - alloc_failed = 1; - } - - endpos = - (tags.chunkId - 1) * dev->nDataBytesPerChunk + - tags.byteCount; - if (in && - in->variantType == YAFFS_OBJECT_TYPE_FILE - && in->variant.fileVariant.scannedFileSize < - endpos) { - in->variant.fileVariant. - scannedFileSize = endpos; - if (!dev->useHeaderFileSize) { - in->variant.fileVariant. - fileSize = - in->variant.fileVariant. - scannedFileSize; - } - - } - /* T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId)); */ - } else { - /* chunkId == 0, so it is an ObjectHeader. - * Thus, we read in the object header and make the object - */ - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; - - yaffs_ReadChunkWithTagsFromNAND(dev, chunk, - chunkData, - NULL); - - oh = (yaffs_ObjectHeader *) chunkData; - - in = yaffs_FindObjectByNumber(dev, - tags.objectId); - if (in && in->variantType != oh->type) { - /* This should not happen, but somehow - * Wev'e ended up with an objectId that has been reused but not yet - * deleted, and worse still it has changed type. Delete the old object. - */ - - yaffs_DestroyObject(in); - - in = 0; - } - - in = yaffs_FindOrCreateObjectByNumber(dev, - tags. - objectId, - oh->type); - - if(!in) - alloc_failed = 1; - - if (in && oh->shadowsObject > 0) { - yaffs_HandleShadowedObject(dev, - oh-> - shadowsObject, - 0); - } - - if (in && in->valid) { - /* We have already filled this one. We have a duplicate and need to resolve it. */ - - unsigned existingSerial = in->serial; - unsigned newSerial = tags.serialNumber; - - if (dev->isYaffs2 || - ((existingSerial + 1) & 3) == - newSerial) { - /* Use new one - destroy the exisiting one */ - yaffs_DeleteChunk(dev, - in->chunkId, - 1, __LINE__); - in->valid = 0; - } else { - /* Use existing - destroy this one. */ - yaffs_DeleteChunk(dev, chunk, 1, - __LINE__); - } - } - - if (in && !in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == YAFFS_OBJECTID_LOSTNFOUND)) { - /* We only load some info, don't fiddle with directory structure */ - in->valid = 1; - in->variantType = 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->chunkId = chunk; - - } else if (in && !in->valid) { - /* we need to load this info */ - - in->valid = 1; - in->variantType = 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->chunkId = chunk; - - yaffs_SetObjectName(in, oh->name); - in->dirty = 0; - - /* directory stuff... - * hook up to parent - */ - - parent = - yaffs_FindOrCreateObjectByNumber - (dev, oh->parentObjectId, - YAFFS_OBJECT_TYPE_DIRECTORY); - if (parent->variantType == - YAFFS_OBJECT_TYPE_UNKNOWN) { - /* Set up as a directory */ - parent->variantType = - YAFFS_OBJECT_TYPE_DIRECTORY; - INIT_LIST_HEAD(&parent->variant. - directoryVariant. - children); - } else if (parent->variantType != - 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->lostNFoundDir; - } - - yaffs_AddObjectToDirectory(parent, in); - - if (0 && (parent == dev->deletedDir || - parent == dev->unlinkedDir)) { - in->deleted = 1; /* If it is unlinked at start up then it wants deleting */ - dev->nDeletedFiles++; - } - /* 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->variantType) { - case YAFFS_OBJECT_TYPE_UNKNOWN: - /* Todo got a problem */ - break; - case YAFFS_OBJECT_TYPE_FILE: - if (dev->isYaffs2 - && oh->isShrink) { - /* Prune back the shrunken chunks */ - yaffs_PruneResizedChunks - (in, oh->fileSize); - /* Mark the block as having a shrinkHeader */ - bi->hasShrinkHeader = 1; - } - - if (dev->useHeaderFileSize) - - in->variant.fileVariant. - fileSize = - oh->fileSize; - - break; - case YAFFS_OBJECT_TYPE_HARDLINK: - in->variant.hardLinkVariant. - equivalentObjectId = - oh->equivalentObjectId; - in->hardLinks.next = - (struct list_head *) - hardList; - hardList = 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.symLinkVariant.alias = - yaffs_CloneString(oh->alias); - if(!in->variant.symLinkVariant.alias) - alloc_failed = 1; - break; - } - - if (parent == dev->deletedDir) { - yaffs_DestroyObject(in); - bi->hasShrinkHeader = 1; - } - } - } - } - - 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->blockState = state; - - /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState == YAFFS_BLOCK_STATE_FULL) { - yaffs_BlockBecameDirty(dev, blk); - } - - } - - if (blockIndex) { - YFREE(blockIndex); - } - - - /* 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. + /* + * Sort out state of unlinked and deleted objects after scanning. */ + struct list_head *i; + struct list_head *n; + struct yaffs_obj *l; - yaffs_HardlinkFixup(dev,hardList); + if (dev->read_only) + return; - /* Handle the unlinked files. Since they were left in an unlinked state we should - * just delete them. - */ - { - struct list_head *i; - struct list_head *n; - - yaffs_Object *l; - /* Soft delete all the unlinked files */ - list_for_each_safe(i, n, - &dev->unlinkedDir->variant.directoryVariant. - children) { - if (i) { - l = list_entry(i, yaffs_Object, siblings); - yaffs_DestroyObject(l); - } - } + /* Soft delete all the unlinked files */ + list_for_each_safe(i, n, + &dev->unlinked_dir->variant.dir_variant.children) { + l = list_entry(i, struct yaffs_obj, siblings); + yaffs_del_obj(l); } - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); - - if(alloc_failed){ - return YAFFS_FAIL; + list_for_each_safe(i, n, &dev->del_dir->variant.dir_variant.children) { + l = list_entry(i, struct yaffs_obj, siblings); + yaffs_del_obj(l); } - - T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR))); - - - return YAFFS_OK; } -static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in) -{ - __u8 *chunkData; - yaffs_ObjectHeader *oh; - yaffs_Device *dev = in->myDev; - yaffs_ExtendedTags tags; - - if(!in) - return; - -#if 0 - T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR), - in->objectId, - in->lazyLoaded ? "not yet" : "already")); -#endif - - if(in->lazyLoaded){ - in->lazyLoaded = 0; - chunkData = yaffs_GetTempBuffer(dev, __LINE__); - - yaffs_ReadChunkWithTagsFromNAND(dev, in->chunkId, - chunkData, &tags); - oh = (yaffs_ObjectHeader *) chunkData; - - in->yst_mode = oh->yst_mode; -#ifdef CONFIG_YAFFS_WINCE - in->win_atime[0] = oh->win_atime[0]; - in->win_ctime[0] = oh->win_ctime[0]; - in->win_mtime[0] = oh->win_mtime[0]; - in->win_atime[1] = oh->win_atime[1]; - in->win_ctime[1] = oh->win_ctime[1]; - in->win_mtime[1] = oh->win_mtime[1]; -#else - in->yst_uid = oh->yst_uid; - in->yst_gid = oh->yst_gid; - in->yst_atime = oh->yst_atime; - in->yst_mtime = oh->yst_mtime; - in->yst_ctime = oh->yst_ctime; - in->yst_rdev = oh->yst_rdev; - -#endif - yaffs_SetObjectName(in, oh->name); - - if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){ - in->variant.symLinkVariant.alias = - yaffs_CloneString(oh->alias); - } +/* + * This code iterates through all the objects making sure that they are rooted. + * Any unrooted objects are re-rooted in lost+found. + * An object needs to be in one of: + * - Directly under deleted, unlinked + * - Directly or indirectly under root. + * + * Note: + * This code assumes that we don't ever change the current relationships + * between directories: + * root_dir->parent == unlinked_dir->parent == del_dir->parent == NULL + * lost-n-found->parent == root_dir + * + * This fixes the problem where directories might have inadvertently been + * deleted leaving the object "hanging" without being rooted in the + * directory tree. + */ - yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__); - } +static int yaffs_has_null_parent(struct yaffs_dev *dev, struct yaffs_obj *obj) +{ + return (obj == dev->del_dir || + obj == dev->unlinked_dir || obj == dev->root_dir); } -static int yaffs_ScanBackwards(yaffs_Device * dev) +static void yaffs_fix_hanging_objs(struct yaffs_dev *dev) { - yaffs_ExtendedTags tags; - int blk; - int blockIterator; - int startIterator; - int endIterator; - int nBlocksToScan = 0; - - int chunk; - int c; - yaffs_BlockState state; - yaffs_Object *hardList = NULL; - yaffs_BlockInfo *bi; - int sequenceNumber; - yaffs_ObjectHeader *oh; - yaffs_Object *in; - yaffs_Object *parent; - int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1; - int itsUnlinked; - __u8 *chunkData; - - int fileSize; - int isShrink; - int foundChunksInBlock; - int equivalentObjectId; - int alloc_failed = 0; - - - yaffs_BlockIndex *blockIndex = NULL; - int altBlockIndex = 0; - - if (!dev->isYaffs2) { - T(YAFFS_TRACE_SCAN, - (TSTR("yaffs_ScanBackwards is only for YAFFS2!" TENDSTR))); - return YAFFS_FAIL; - } - - T(YAFFS_TRACE_SCAN, - (TSTR - ("yaffs_ScanBackwards starts intstartblk %d intendblk %d..." - TENDSTR), dev->internalStartBlock, dev->internalEndBlock)); - - - dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER; - - blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex)); - - if(!blockIndex) { - blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex)); - altBlockIndex = 1; - } - - if(!blockIndex) { - T(YAFFS_TRACE_SCAN, - (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR))); - return YAFFS_FAIL; - } - - dev->blocksInCheckpoint = 0; - - chunkData = yaffs_GetTempBuffer(dev, __LINE__); - - /* Scan all the blocks to determine their state */ - for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) { - bi = yaffs_GetBlockInfo(dev, blk); - yaffs_ClearChunkBits(dev, blk); - bi->pagesInUse = 0; - bi->softDeletions = 0; - - yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber); - - bi->blockState = state; - bi->sequenceNumber = sequenceNumber; - - if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA) - bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT; - - T(YAFFS_TRACE_SCAN_DEBUG, - (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk, - state, sequenceNumber)); - - - if(state == YAFFS_BLOCK_STATE_CHECKPOINT){ - dev->blocksInCheckpoint++; - - } 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->nErasedBlocks++; - dev->nFreeChunks += dev->nChunksPerBlock; - } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) { - - /* Determine the highest sequence number */ - if (dev->isYaffs2 && - sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER && - sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) { - - blockIndex[nBlocksToScan].seq = sequenceNumber; - blockIndex[nBlocksToScan].block = blk; - - nBlocksToScan++; - - if (sequenceNumber >= dev->sequenceNumber) { - dev->sequenceNumber = sequenceNumber; - } - } else if (dev->isYaffs2) { - /* TODO: Nasty sequence number! */ - T(YAFFS_TRACE_SCAN, - (TSTR - ("Block scanning block %d has bad sequence number %d" - TENDSTR), blk, sequenceNumber)); - - } - } - } - - T(YAFFS_TRACE_SCAN, - (TSTR("%d blocks to be sorted..." TENDSTR), nBlocksToScan)); - - - - YYIELD(); - - /* Sort the blocks */ -#ifndef CONFIG_YAFFS_USE_OWN_SORT - { - /* Use qsort now. */ - yaffs_qsort(blockIndex, nBlocksToScan, sizeof(yaffs_BlockIndex), ybicmp); - } -#else - { - /* Dungy old bubble sort... */ - - yaffs_BlockIndex temp; - int i; - int j; - - for (i = 0; i < nBlocksToScan; i++) - for (j = i + 1; j < nBlocksToScan; j++) - if (blockIndex[i].seq > blockIndex[j].seq) { - temp = blockIndex[j]; - blockIndex[j] = blockIndex[i]; - blockIndex[i] = temp; - } - } -#endif - - YYIELD(); - - T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR))); - - /* Now scan the blocks looking at the data. */ - startIterator = 0; - endIterator = nBlocksToScan - 1; - T(YAFFS_TRACE_SCAN_DEBUG, - (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan)); - - /* For each block.... backwards */ - for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator; - blockIterator--) { - /* Cooperative multitasking! This loop can run for so - long that watchdog timers expire. */ - YYIELD(); - - /* get the block to scan in the correct order */ - blk = blockIndex[blockIterator].block; - - bi = yaffs_GetBlockInfo(dev, blk); - - - state = bi->blockState; - - /* For each chunk in each block that needs scanning.... */ - foundChunksInBlock = 0; - for (c = dev->nChunksPerBlock - 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->nChunksPerBlock + c; - - yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL, - &tags); - - /* Let's have a good look at this chunk... */ - - if (!tags.chunkUsed) { - /* 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(foundChunksInBlock) - { - /* 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->nErasedBlocks++; - } else { - if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING || - state == YAFFS_BLOCK_STATE_ALLOCATING) { - if(dev->sequenceNumber == bi->sequenceNumber) { - /* 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->allocationBlock = blk; - dev->allocationPage = c; - dev->allocationBlockFinder = blk; - } - else { - /* This is a partially written block that is not - * the current allocation block. This block must have - * had a write failure, so set up for retirement. - */ - - bi->needsRetiring = 1; - bi->gcPrioritise = 1; - - T(YAFFS_TRACE_ALWAYS, - (TSTR("Partially written block %d being set for retirement" TENDSTR), - blk)); - } - - } - - } - - dev->nFreeChunks++; - - } else if (tags.chunkId > 0) { - /* chunkId > 0 so it is a data chunk... */ - unsigned int endpos; - __u32 chunkBase = - (tags.chunkId - 1) * dev->nDataBytesPerChunk; - - foundChunksInBlock = 1; - - - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; - - in = yaffs_FindOrCreateObjectByNumber(dev, - tags. - objectId, - YAFFS_OBJECT_TYPE_FILE); - if(!in){ - /* Out of memory */ - alloc_failed = 1; - } - - if (in && - in->variantType == YAFFS_OBJECT_TYPE_FILE - && chunkBase < - in->variant.fileVariant.shrinkSize) { - /* This has not been invalidated by a resize */ - if(!yaffs_PutChunkIntoFile(in, tags.chunkId, - chunk, -1)){ - alloc_failed = 1; - } + struct yaffs_obj *obj; + struct yaffs_obj *parent; + int i; + struct list_head *lh; + struct list_head *n; + int depth_limit; + int hanging; - /* 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 = - (tags.chunkId - - 1) * dev->nDataBytesPerChunk + - tags.byteCount; - - if (!in->valid && /* have not got an object header yet */ - in->variant.fileVariant. - scannedFileSize < endpos) { - in->variant.fileVariant. - scannedFileSize = endpos; - in->variant.fileVariant. - fileSize = - in->variant.fileVariant. - scannedFileSize; - } + if (dev->read_only) + return; - } else if(in) { - /* This chunk has been invalidated by a resize, so delete */ - yaffs_DeleteChunk(dev, chunk, 1, __LINE__); + /* Iterate through the objects in each hash entry, + * looking at each object. + * Make sure it is rooted. + */ - } + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each_safe(lh, n, &dev->obj_bucket[i].list) { + obj = list_entry(lh, struct yaffs_obj, hash_link); + parent = obj->parent; + + if (yaffs_has_null_parent(dev, obj)) { + /* These directories are not hanging */ + hanging = 0; + } else if (!parent || + parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) { + hanging = 1; + } else if (yaffs_has_null_parent(dev, parent)) { + hanging = 0; } else { - /* chunkId == 0, so it is an ObjectHeader. - * Thus, we read in the object header and make the object + /* + * Need to follow the parent chain to + * see if it is hanging. */ - foundChunksInBlock = 1; - - yaffs_SetChunkBit(dev, blk, c); - bi->pagesInUse++; - - oh = NULL; - in = NULL; - - if (tags.extraHeaderInfoAvailable) { - in = yaffs_FindOrCreateObjectByNumber - (dev, tags.objectId, - tags.extraObjectType); - } - - if (!in || -#ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD - !in->valid || -#endif - tags.extraShadows || - (!in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == 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. - */ - - yaffs_ReadChunkWithTagsFromNAND(dev, - chunk, - chunkData, - NULL); - - oh = (yaffs_ObjectHeader *) chunkData; - - if (!in) - in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type); - - } - - 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.objectId, chunk)); - - } - - 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->variantType == YAFFS_OBJECT_TYPE_FILE) && - ((oh && - oh-> type == YAFFS_OBJECT_TYPE_FILE)|| - (tags.extraHeaderInfoAvailable && - tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE)) - ) { - __u32 thisSize = - (oh) ? oh->fileSize : tags. - extraFileLength; - __u32 parentObjectId = - (oh) ? oh-> - parentObjectId : tags. - extraParentObjectId; - unsigned isShrink = - (oh) ? oh->isShrink : tags. - extraIsShrinkHeader; - - /* If it is deleted (unlinked at start also means deleted) - * we treat the file size as being zeroed at this point. - */ - if (parentObjectId == - YAFFS_OBJECTID_DELETED - || parentObjectId == - YAFFS_OBJECTID_UNLINKED) { - thisSize = 0; - isShrink = 1; - } - - if (isShrink && - in->variant.fileVariant. - shrinkSize > thisSize) { - in->variant.fileVariant. - shrinkSize = - thisSize; - } - - if (isShrink) { - bi->hasShrinkHeader = 1; - } - - } - /* Use existing - destroy this one. */ - yaffs_DeleteChunk(dev, chunk, 1, __LINE__); - + hanging = 0; + depth_limit = 100; + + while (parent != dev->root_dir && + parent->parent && + parent->parent->variant_type == + YAFFS_OBJECT_TYPE_DIRECTORY && + depth_limit > 0) { + parent = parent->parent; + depth_limit--; } - - if (!in->valid && - (tags.objectId == YAFFS_OBJECTID_ROOT || - tags.objectId == - YAFFS_OBJECTID_LOSTNFOUND)) { - /* We only load some info, don't fiddle with directory structure */ - in->valid = 1; - - if(oh) { - in->variantType = 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 - } else { - in->variantType = tags.extraObjectType; - in->lazyLoaded = 1; - } - - in->chunkId = chunk; - - } else if (!in->valid) { - /* we need to load this info */ - - in->valid = 1; - in->chunkId = chunk; - - if(oh) { - in->variantType = 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->shadowsObject > 0) - yaffs_HandleShadowedObject(dev, - oh-> - shadowsObject, - 1); - - - yaffs_SetObjectName(in, oh->name); - parent = - yaffs_FindOrCreateObjectByNumber - (dev, oh->parentObjectId, - YAFFS_OBJECT_TYPE_DIRECTORY); - - fileSize = oh->fileSize; - isShrink = oh->isShrink; - equivalentObjectId = oh->equivalentObjectId; - - } - else { - in->variantType = tags.extraObjectType; - parent = - yaffs_FindOrCreateObjectByNumber - (dev, tags.extraParentObjectId, - YAFFS_OBJECT_TYPE_DIRECTORY); - fileSize = tags.extraFileLength; - isShrink = tags.extraIsShrinkHeader; - equivalentObjectId = tags.extraEquivalentObjectId; - in->lazyLoaded = 1; - - } - in->dirty = 0; - - /* directory stuff... - * hook up to parent - */ - - if (parent->variantType == - YAFFS_OBJECT_TYPE_UNKNOWN) { - /* Set up as a directory */ - parent->variantType = - YAFFS_OBJECT_TYPE_DIRECTORY; - INIT_LIST_HEAD(&parent->variant. - directoryVariant. - children); - } else if (parent->variantType != - 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->lostNFoundDir; - } - - yaffs_AddObjectToDirectory(parent, in); - - itsUnlinked = (parent == dev->deletedDir) || - (parent == dev->unlinkedDir); - - if (isShrink) { - /* Mark the block as having a shrinkHeader */ - bi->hasShrinkHeader = 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->variantType) { - case YAFFS_OBJECT_TYPE_UNKNOWN: - /* Todo got a problem */ - break; - case YAFFS_OBJECT_TYPE_FILE: - - if (in->variant.fileVariant. - scannedFileSize < fileSize) { - /* 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.fileVariant.fileSize = fileSize; - in->variant.fileVariant.scannedFileSize = - in->variant.fileVariant.fileSize; - } - - if (isShrink && - in->variant.fileVariant.shrinkSize > fileSize) { - in->variant.fileVariant.shrinkSize = fileSize; - } - - break; - case YAFFS_OBJECT_TYPE_HARDLINK: - if(!itsUnlinked) { - in->variant.hardLinkVariant.equivalentObjectId = - equivalentObjectId; - in->hardLinks.next = - (struct list_head *) hardList; - hardList = 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.symLinkVariant.alias = - yaffs_CloneString(oh-> - alias); - if(!in->variant.symLinkVariant.alias) - alloc_failed = 1; - } - break; - } - - } - + if (parent != dev->root_dir) + hanging = 1; } - - } /* 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->blockState = state; - - /* Now let's see if it was dirty */ - if (bi->pagesInUse == 0 && - !bi->hasShrinkHeader && - bi->blockState == YAFFS_BLOCK_STATE_FULL) { - yaffs_BlockBecameDirty(dev, blk); - } - - } - - if (altBlockIndex) - YFREE_ALT(blockIndex); - else - YFREE(blockIndex); - - /* 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_HardlinkFixup(dev,hardList); - - - /* - * Sort out state of unlinked and deleted objects. - */ - { - struct list_head *i; - struct list_head *n; - - yaffs_Object *l; - - /* Soft delete all the unlinked files */ - list_for_each_safe(i, n, - &dev->unlinkedDir->variant.directoryVariant. - children) { - if (i) { - l = list_entry(i, yaffs_Object, siblings); - yaffs_DestroyObject(l); - } - } - - /* Soft delete all the deletedDir files */ - list_for_each_safe(i, n, - &dev->deletedDir->variant.directoryVariant. - children) { - if (i) { - l = list_entry(i, yaffs_Object, siblings); - yaffs_DestroyObject(l); - + if (hanging) { + yaffs_trace(YAFFS_TRACE_SCAN, + "Hanging object %d moved to lost and found", + obj->obj_id); + yaffs_add_obj_to_dir(dev->lost_n_found, obj); } } } - - yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__); - - if(alloc_failed){ - return YAFFS_FAIL; - } - - T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR))); - - return YAFFS_OK; } -/*------------------------------ Directory Functions ----------------------------- */ - -static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj) +/* + * Delete directory contents for cleaning up lost and found. + */ +static void yaffs_del_dir_contents(struct yaffs_obj *dir) { - yaffs_Device *dev = obj->myDev; + struct yaffs_obj *obj; + struct list_head *lh; + struct list_head *n; - if(dev && dev->removeObjectCallback) - dev->removeObjectCallback(obj); + if (dir->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + BUG(); - list_del_init(&obj->siblings); - obj->parent = NULL; + list_for_each_safe(lh, n, &dir->variant.dir_variant.children) { + obj = list_entry(lh, struct yaffs_obj, siblings); + if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) + yaffs_del_dir_contents(obj); + yaffs_trace(YAFFS_TRACE_SCAN, + "Deleting lost_found object %d", + obj->obj_id); + yaffs_unlink_obj(obj); + } } - -static void yaffs_AddObjectToDirectory(yaffs_Object * directory, - yaffs_Object * obj) +static void yaffs_empty_l_n_f(struct yaffs_dev *dev) { - - if (!directory) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: Trying to add an object to a null pointer directory" - TENDSTR))); - YBUG(); - } - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: Trying to add an object to a non-directory" - TENDSTR))); - YBUG(); - } - - if (obj->siblings.prev == NULL) { - /* Not initialised */ - INIT_LIST_HEAD(&obj->siblings); - - } else if (!list_empty(&obj->siblings)) { - /* If it is holed up somewhere else, un hook it */ - yaffs_RemoveObjectFromDirectory(obj); - } - /* Now add it */ - list_add(&obj->siblings, &directory->variant.directoryVariant.children); - obj->parent = directory; - - if (directory == obj->myDev->unlinkedDir - || directory == obj->myDev->deletedDir) { - obj->unlinked = 1; - obj->myDev->nUnlinkedFiles++; - obj->renameAllowed = 0; - } + yaffs_del_dir_contents(dev->lost_n_found); } -yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory, - const YCHAR * name) + +struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *directory, + const YCHAR *name) { int sum; - struct list_head *i; YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1]; + struct yaffs_obj *l; - yaffs_Object *l; - - if (!name) { + if (!name) return NULL; - } if (!directory) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_FindObjectByName: null pointer directory" - TENDSTR))); - YBUG(); + yaffs_trace(YAFFS_TRACE_ALWAYS, + "tragedy: yaffs_find_by_name: null pointer directory" + ); + BUG(); + return NULL; } - if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR))); - YBUG(); + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "tragedy: yaffs_find_by_name: non-directory" + ); + BUG(); } - sum = yaffs_CalcNameSum(name); + sum = yaffs_calc_name_sum(name); - list_for_each(i, &directory->variant.directoryVariant.children) { - if (i) { - l = list_entry(i, yaffs_Object, siblings); + list_for_each(i, &directory->variant.dir_variant.children) { + l = list_entry(i, struct yaffs_obj, siblings); - yaffs_CheckObjectDetailsLoaded(l); + if (l->parent != directory) + BUG(); - /* Special case for lost-n-found */ - if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) { - if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) { - return l; - } - } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0) - { - /* LostnFound cunk called Objxxx - * Do a real check - */ - yaffs_GetObjectName(l, buffer, - YAFFS_MAX_NAME_LENGTH); - if (yaffs_strncmp(name, buffer,YAFFS_MAX_NAME_LENGTH) == 0) { - return l; - } + yaffs_check_obj_details_loaded(l); - } + /* Special case for lost-n-found */ + if (l->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { + if (!yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME)) + return l; + } else if (l->sum == sum || l->hdr_chunk <= 0) { + /* LostnFound chunk called Objxxx + * Do a real check + */ + yaffs_get_obj_name(l, buffer, + YAFFS_MAX_NAME_LENGTH + 1); + if (!yaffs_strncmp(name, buffer, YAFFS_MAX_NAME_LENGTH)) + return l; } } - return NULL; } - -#if 0 -int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir, - int (*fn) (yaffs_Object *)) -{ - struct list_head *i; - yaffs_Object *l; - - if (!theDir) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_FindObjectByName: null pointer directory" - TENDSTR))); - YBUG(); - } - if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR))); - YBUG(); - } - - list_for_each(i, &theDir->variant.directoryVariant.children) { - if (i) { - l = list_entry(i, yaffs_Object, siblings); - if (l && !fn(l)) { - return YAFFS_FAIL; - } - } - } - - return YAFFS_OK; - -} -#endif - /* GetEquivalentObject dereferences any hard links to get to the * actual object. */ -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj) +struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj) { - if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) { - /* We want the object id of the equivalent object, not this one */ - obj = obj->variant.hardLinkVariant.equivalentObject; - yaffs_CheckObjectDetailsLoaded(obj); + if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_HARDLINK) { + obj = obj->variant.hardlink_variant.equiv_obj; + yaffs_check_obj_details_loaded(obj); } return obj; - } -int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize) -{ - memset(name, 0, buffSize * sizeof(YCHAR)); - - yaffs_CheckObjectDetailsLoaded(obj); +/* + * A note or two on object names. + * * If the object name is missing, we then make one up in the form objnnn + * + * * ASCII names are stored in the object header's name field from byte zero + * * Unicode names are historically stored starting from byte zero. + * + * Then there are automatic Unicode names... + * The purpose of these is to save names in a way that can be read as + * ASCII or Unicode names as appropriate, thus allowing a Unicode and ASCII + * system to share files. + * + * These automatic unicode are stored slightly differently... + * - If the name can fit in the ASCII character space then they are saved as + * ascii names as per above. + * - If the name needs Unicode then the name is saved in Unicode + * starting at oh->name[1]. - if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) { - yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1); - } else if (obj->chunkId <= 0) { - YCHAR locName[20]; + */ +static void yaffs_fix_null_name(struct yaffs_obj *obj, YCHAR *name, + int buffer_size) +{ + /* Create an object name if we could not find one. */ + if (yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH) == 0) { + YCHAR local_name[20]; + YCHAR num_string[20]; + YCHAR *x = &num_string[19]; + unsigned v = obj->obj_id; + num_string[19] = 0; + while (v > 0) { + x--; + *x = '0' + (v % 10); + v /= 10; + } /* make up a name */ - yaffs_sprintf(locName, _Y("%s%d"), YAFFS_LOSTNFOUND_PREFIX, - obj->objectId); - yaffs_strncpy(name, locName, buffSize - 1); - - } -#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - else if (obj->shortName[0]) { - yaffs_strcpy(name, obj->shortName); + yaffs_strcpy(local_name, YAFFS_LOSTNFOUND_PREFIX); + yaffs_strcat(local_name, x); + yaffs_strncpy(name, local_name, buffer_size - 1); } -#endif - else { - __u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__); +} + +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR *name, int buffer_size) +{ + memset(name, 0, buffer_size * sizeof(YCHAR)); + yaffs_check_obj_details_loaded(obj); + if (obj->obj_id == YAFFS_OBJECTID_LOSTNFOUND) { + yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffer_size - 1); + } else if (obj->short_name[0]) { + yaffs_strcpy(name, obj->short_name); + } else if (obj->hdr_chunk > 0) { + int result; + u8 *buffer = yaffs_get_temp_buffer(obj->my_dev); - yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer; + struct yaffs_obj_hdr *oh = (struct yaffs_obj_hdr *)buffer; - memset(buffer, 0, obj->myDev->nDataBytesPerChunk); + memset(buffer, 0, obj->my_dev->data_bytes_per_chunk); - if (obj->chunkId >= 0) { - yaffs_ReadChunkWithTagsFromNAND(obj->myDev, - obj->chunkId, buffer, - NULL); + if (obj->hdr_chunk > 0) { + result = yaffs_rd_chunk_tags_nand(obj->my_dev, + obj->hdr_chunk, + buffer, NULL); } - yaffs_strncpy(name, oh->name, buffSize - 1); + yaffs_load_name_from_oh(obj->my_dev, name, oh->name, + buffer_size); - yaffs_ReleaseTempBuffer(obj->myDev, buffer, __LINE__); + yaffs_release_temp_buffer(obj->my_dev, buffer); } - return yaffs_strlen(name); + yaffs_fix_null_name(obj, name, buffer_size); + + return yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH); } -int yaffs_GetObjectFileLength(yaffs_Object * obj) +loff_t yaffs_get_obj_length(struct yaffs_obj *obj) { - /* Dereference any hard linking */ - obj = yaffs_GetEquivalentObject(obj); + obj = yaffs_get_equivalent_obj(obj); - if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) { - return obj->variant.fileVariant.fileSize; - } - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) { - return yaffs_strlen(obj->variant.symLinkVariant.alias); + if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) + return obj->variant.file_variant.file_size; + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + if (!obj->variant.symlink_variant.alias) + return 0; + return yaffs_strnlen(obj->variant.symlink_variant.alias, + YAFFS_MAX_ALIAS_LENGTH); } else { /* Only a directory should drop through to here */ - return obj->myDev->nDataBytesPerChunk; + return obj->my_dev->data_bytes_per_chunk; } } -int yaffs_GetObjectLinkCount(yaffs_Object * obj) +int yaffs_get_obj_link_count(struct yaffs_obj *obj) { int count = 0; struct list_head *i; - if (!obj->unlinked) { + if (!obj->unlinked) count++; /* the object itself */ - } - list_for_each(i, &obj->hardLinks) { - count++; /* add the hard links; */ - } - return count; + list_for_each(i, &obj->hard_links) + count++; /* add the hard links; */ + + return count; } -int yaffs_GetObjectInode(yaffs_Object * obj) +int yaffs_get_obj_inode(struct yaffs_obj *obj) { - obj = yaffs_GetEquivalentObject(obj); + obj = yaffs_get_equivalent_obj(obj); - return obj->objectId; + return obj->obj_id; } -unsigned yaffs_GetObjectType(yaffs_Object * obj) +unsigned yaffs_get_obj_type(struct yaffs_obj *obj) { - obj = yaffs_GetEquivalentObject(obj); + obj = yaffs_get_equivalent_obj(obj); - switch (obj->variantType) { + switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: return DT_REG; break; @@ -6725,605 +4532,501 @@ unsigned yaffs_GetObjectType(yaffs_Object * obj) return DT_BLK; if (S_ISSOCK(obj->yst_mode)) return DT_SOCK; + return DT_REG; + break; default: return DT_REG; break; } } -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj) -{ - obj = yaffs_GetEquivalentObject(obj); - if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) { - return yaffs_CloneString(obj->variant.symLinkVariant.alias); - } else { - return yaffs_CloneString(_Y("")); - } -} - -#ifndef CONFIG_YAFFS_WINCE - -int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr) -{ - unsigned int valid = attr->ia_valid; - - if (valid & ATTR_MODE) - obj->yst_mode = attr->ia_mode; - if (valid & ATTR_UID) - obj->yst_uid = attr->ia_uid; - if (valid & ATTR_GID) - obj->yst_gid = attr->ia_gid; - - if (valid & ATTR_ATIME) - obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime); - if (valid & ATTR_CTIME) - obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime); - if (valid & ATTR_MTIME) - obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime); - - if (valid & ATTR_SIZE) - yaffs_ResizeFile(obj, attr->ia_size); - - yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0); - - return YAFFS_OK; - -} -int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr) +YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj) { - unsigned int valid = 0; - - attr->ia_mode = obj->yst_mode; - valid |= ATTR_MODE; - attr->ia_uid = obj->yst_uid; - valid |= ATTR_UID; - attr->ia_gid = obj->yst_gid; - valid |= ATTR_GID; - - Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime; - valid |= ATTR_ATIME; - Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime; - valid |= ATTR_CTIME; - Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime; - valid |= ATTR_MTIME; - - attr->ia_size = yaffs_GetFileSize(obj); - valid |= ATTR_SIZE; - - attr->ia_valid = valid; - - return YAFFS_OK; - -} - -#endif - -#if 0 -int yaffs_DumpObject(yaffs_Object * obj) -{ - YCHAR name[257]; - - yaffs_GetObjectName(obj, name, 256); - - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d" - " chunk %d type %d size %d\n" - TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name, - obj->dirty, obj->valid, obj->serial, obj->sum, obj->chunkId, - yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj))); - - return YAFFS_OK; + obj = yaffs_get_equivalent_obj(obj); + if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) + return yaffs_clone_str(obj->variant.symlink_variant.alias); + else + return yaffs_clone_str(_Y("")); } -#endif -/*---------------------------- Initialisation code -------------------------------------- */ +/*--------------------------- Initialisation code -------------------------- */ -static int yaffs_CheckDevFunctions(const yaffs_Device * dev) +static int yaffs_check_dev_fns(const struct yaffs_dev *dev) { - /* Common functions, gotta have */ - if (!dev->eraseBlockInNAND || !dev->initialiseNAND) + if (!dev->param.erase_fn || !dev->param.initialise_flash_fn) return 0; -#ifdef CONFIG_YAFFS_YAFFS2 - /* Can use the "with tags" style interface for yaffs1 or yaffs2 */ - if (dev->writeChunkWithTagsToNAND && - dev->readChunkWithTagsFromNAND && - !dev->writeChunkToNAND && - !dev->readChunkFromNAND && - dev->markNANDBlockBad && dev->queryNANDBlock) + if (dev->param.write_chunk_tags_fn && + dev->param.read_chunk_tags_fn && + !dev->param.write_chunk_fn && + !dev->param.read_chunk_fn && + dev->param.bad_block_fn && dev->param.query_block_fn) return 1; -#endif /* Can use the "spare" style interface for yaffs1 */ - if (!dev->isYaffs2 && - !dev->writeChunkWithTagsToNAND && - !dev->readChunkWithTagsFromNAND && - dev->writeChunkToNAND && - dev->readChunkFromNAND && - !dev->markNANDBlockBad && !dev->queryNANDBlock) + if (!dev->param.is_yaffs2 && + !dev->param.write_chunk_tags_fn && + !dev->param.read_chunk_tags_fn && + dev->param.write_chunk_fn && + dev->param.read_chunk_fn && + !dev->param.bad_block_fn && !dev->param.query_block_fn) return 1; return 0; /* bad */ } - -static int yaffs_CreateInitialDirectories(yaffs_Device *dev) -{ - /* Initialise the unlinked, deleted, root and lost and found directories */ - - dev->lostNFoundDir = dev->rootDir = NULL; - dev->unlinkedDir = dev->deletedDir = NULL; - - dev->unlinkedDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); - - dev->deletedDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); - - dev->rootDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_ROOT, - YAFFS_ROOT_MODE | S_IFDIR); - dev->lostNFoundDir = - yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND, - YAFFS_LOSTNFOUND_MODE | S_IFDIR); - - if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){ - yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir); +static int yaffs_create_initial_dir(struct yaffs_dev *dev) +{ + /* Initialise the unlinked, deleted, root and lost+found directories */ + dev->lost_n_found = dev->root_dir = NULL; + dev->unlinked_dir = dev->del_dir = NULL; + dev->unlinked_dir = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR); + dev->del_dir = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_DELETED, S_IFDIR); + dev->root_dir = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_ROOT, + YAFFS_ROOT_MODE | S_IFDIR); + dev->lost_n_found = + yaffs_create_fake_dir(dev, YAFFS_OBJECTID_LOSTNFOUND, + YAFFS_LOSTNFOUND_MODE | S_IFDIR); + + if (dev->lost_n_found && dev->root_dir && dev->unlinked_dir + && dev->del_dir) { + yaffs_add_obj_to_dir(dev->root_dir, dev->lost_n_found); return YAFFS_OK; } - return YAFFS_FAIL; } -int yaffs_GutsInitialise(yaffs_Device * dev) +int yaffs_guts_initialise(struct yaffs_dev *dev) { int init_failed = 0; unsigned x; int bits; - T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_GutsInitialise()" TENDSTR))); + yaffs_trace(YAFFS_TRACE_TRACING, "yaffs: yaffs_guts_initialise()"); /* Check stuff that must be set */ if (!dev) { - T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Need a device" TENDSTR))); + yaffs_trace(YAFFS_TRACE_ALWAYS, + "yaffs: Need a device" + ); + return YAFFS_FAIL; + } + + if (dev->is_mounted) { + yaffs_trace(YAFFS_TRACE_ALWAYS, "device already mounted"); return YAFFS_FAIL; } - dev->internalStartBlock = dev->startBlock; - dev->internalEndBlock = dev->endBlock; - dev->blockOffset = 0; - dev->chunkOffset = 0; - dev->nFreeChunks = 0; + dev->internal_start_block = dev->param.start_block; + dev->internal_end_block = dev->param.end_block; + dev->block_offset = 0; + dev->chunk_offset = 0; + dev->n_free_chunks = 0; + + dev->gc_block = 0; - if (dev->startBlock == 0) { - dev->internalStartBlock = dev->startBlock + 1; - dev->internalEndBlock = dev->endBlock + 1; - dev->blockOffset = 1; - dev->chunkOffset = dev->nChunksPerBlock; + if (dev->param.start_block == 0) { + dev->internal_start_block = dev->param.start_block + 1; + dev->internal_end_block = dev->param.end_block + 1; + dev->block_offset = 1; + dev->chunk_offset = dev->param.chunks_per_block; } /* Check geometry parameters. */ - if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) || - (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) || - dev->nChunksPerBlock < 2 || - dev->nReservedBlocks < 2 || - dev->internalStartBlock <= 0 || - dev->internalEndBlock <= 0 || - dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2) // otherwise it is too small - ) { - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s " - TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : "")); + if ((!dev->param.inband_tags && dev->param.is_yaffs2 && + dev->param.total_bytes_per_chunk < 1024) || + (!dev->param.is_yaffs2 && + dev->param.total_bytes_per_chunk < 512) || + (dev->param.inband_tags && !dev->param.is_yaffs2) || + dev->param.chunks_per_block < 2 || + dev->param.n_reserved_blocks < 2 || + dev->internal_start_block <= 0 || + dev->internal_end_block <= 0 || + dev->internal_end_block <= + (dev->internal_start_block + dev->param.n_reserved_blocks + 2) + ) { + /* otherwise it is too small */ + yaffs_trace(YAFFS_TRACE_ALWAYS, + "NAND geometry problems: chunk size %d, type is yaffs%s, inband_tags %d ", + dev->param.total_bytes_per_chunk, + dev->param.is_yaffs2 ? "2" : "", + dev->param.inband_tags); return YAFFS_FAIL; } - if (yaffs_InitialiseNAND(dev) != YAFFS_OK) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: InitialiseNAND failed" TENDSTR))); + if (yaffs_init_nand(dev) != YAFFS_OK) { + yaffs_trace(YAFFS_TRACE_ALWAYS, "InitialiseNAND failed"); return YAFFS_FAIL; } + /* Sort out space for inband tags, if required */ + if (dev->param.inband_tags) + dev->data_bytes_per_chunk = + dev->param.total_bytes_per_chunk - + sizeof(struct yaffs_packed_tags2_tags_only); + else + dev->data_bytes_per_chunk = dev->param.total_bytes_per_chunk; + /* Got the right mix of functions? */ - if (!yaffs_CheckDevFunctions(dev)) { + if (!yaffs_check_dev_fns(dev)) { /* Function missing */ - T(YAFFS_TRACE_ALWAYS, - (TSTR - ("yaffs: device function(s) missing or wrong\n" TENDSTR))); + yaffs_trace(YAFFS_TRACE_ALWAYS, + "device function(s) missing or wrong"); return YAFFS_FAIL; } - /* This is really a compilation check. */ - if (!yaffs_CheckStructures()) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs_CheckStructures failed\n" TENDSTR))); - return YAFFS_FAIL; - } - - if (dev->isMounted) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: device already mounted\n" TENDSTR))); - return YAFFS_FAIL; - } - - /* Finished with most checks. One or two more checks happen later on too. */ - - dev->isMounted = 1; - + /* Finished with most checks. Further checks happen later on too. */ + dev->is_mounted = 1; /* OK now calculate a few things for the device */ /* * Calculate all the chunk size manipulation numbers: */ - /* Start off assuming it is a power of 2 */ - dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk); - dev->chunkMask = (1<<dev->chunkShift) - 1; - - if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){ - /* Yes it is a power of 2, disable crumbs */ - dev->crumbMask = 0; - dev->crumbShift = 0; - dev->crumbsPerChunk = 0; - } else { - /* Not a power of 2, use crumbs instead */ - dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart)); - dev->crumbMask = (1<<dev->crumbShift)-1; - dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift); - dev->chunkShift = 0; - dev->chunkMask = 0; - } - + x = dev->data_bytes_per_chunk; + /* We always use dev->chunk_shift and dev->chunk_div */ + dev->chunk_shift = calc_shifts(x); + x >>= dev->chunk_shift; + dev->chunk_div = x; + /* We only use chunk mask if chunk_div is 1 */ + dev->chunk_mask = (1 << dev->chunk_shift) - 1; /* - * Calculate chunkGroupBits. - * We need to find the next power of 2 > than internalEndBlock + * Calculate chunk_grp_bits. + * We need to find the next power of 2 > than internal_end_block */ - x = dev->nChunksPerBlock * (dev->internalEndBlock + 1); + x = dev->param.chunks_per_block * (dev->internal_end_block + 1); - bits = ShiftsGE(x); + bits = calc_shifts_ceiling(x); /* Set up tnode width if wide tnodes are enabled. */ - if(!dev->wideTnodesDisabled){ + if (!dev->param.wide_tnodes_disabled) { /* bits must be even so that we end up with 32-bit words */ - if(bits & 1) + if (bits & 1) bits++; - if(bits < 16) - dev->tnodeWidth = 16; + if (bits < 16) + dev->tnode_width = 16; else - dev->tnodeWidth = bits; + dev->tnode_width = bits; + } else { + dev->tnode_width = 16; } - else - dev->tnodeWidth = 16; - dev->tnodeMask = (1<<dev->tnodeWidth)-1; + dev->tnode_mask = (1 << dev->tnode_width) - 1; /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled), * so if the bitwidth of the * chunk range we're using is greater than 16 we need - * to figure out chunk shift and chunkGroupSize + * to figure out chunk shift and chunk_grp_size */ - if (bits <= dev->tnodeWidth) - dev->chunkGroupBits = 0; + if (bits <= dev->tnode_width) + dev->chunk_grp_bits = 0; else - dev->chunkGroupBits = bits - dev->tnodeWidth; + dev->chunk_grp_bits = bits - dev->tnode_width; + dev->tnode_size = (dev->tnode_width * YAFFS_NTNODES_LEVEL0) / 8; + if (dev->tnode_size < sizeof(struct yaffs_tnode)) + dev->tnode_size = sizeof(struct yaffs_tnode); - dev->chunkGroupSize = 1 << dev->chunkGroupBits; + dev->chunk_grp_size = 1 << dev->chunk_grp_bits; - if (dev->nChunksPerBlock < dev->chunkGroupSize) { + if (dev->param.chunks_per_block < dev->chunk_grp_size) { /* We have a problem because the soft delete won't work if * the chunk group size > chunks per block. * This can be remedied by using larger "virtual blocks". */ - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: chunk group too large\n" TENDSTR))); + yaffs_trace(YAFFS_TRACE_ALWAYS, "chunk group too large"); return YAFFS_FAIL; } - /* OK, we've finished verifying the device, lets continue with initialisation */ + /* Finished verifying the device, continue with initialisation */ /* More device initialisation */ - dev->garbageCollections = 0; - dev->passiveGarbageCollections = 0; - dev->currentDirtyChecker = 0; - dev->bufferedBlock = -1; - dev->doingBufferedBlockRewrite = 0; - dev->nDeletedFiles = 0; - dev->nBackgroundDeletions = 0; - dev->nUnlinkedFiles = 0; - dev->eccFixed = 0; - dev->eccUnfixed = 0; - dev->tagsEccFixed = 0; - dev->tagsEccUnfixed = 0; - dev->nErasureFailures = 0; - dev->nErasedBlocks = 0; - dev->isDoingGC = 0; - dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */ + dev->all_gcs = 0; + dev->passive_gc_count = 0; + dev->oldest_dirty_gc_count = 0; + dev->bg_gcs = 0; + dev->gc_block_finder = 0; + dev->buffered_block = -1; + dev->doing_buffered_block_rewrite = 0; + dev->n_deleted_files = 0; + dev->n_bg_deletions = 0; + dev->n_unlinked_files = 0; + dev->n_ecc_fixed = 0; + dev->n_ecc_unfixed = 0; + dev->n_tags_ecc_fixed = 0; + dev->n_tags_ecc_unfixed = 0; + dev->n_erase_failures = 0; + dev->n_erased_blocks = 0; + dev->gc_disable = 0; + dev->has_pending_prioritised_gc = 1; + /* Assume the worst for now, will get fixed on first GC */ + INIT_LIST_HEAD(&dev->dirty_dirs); + dev->oldest_dirty_seq = 0; + dev->oldest_dirty_block = 0; /* Initialise temporary buffers and caches. */ - if(!yaffs_InitialiseTempBuffers(dev)) + if (!yaffs_init_tmp_buffers(dev)) init_failed = 1; - dev->srCache = NULL; - dev->gcCleanupList = NULL; + dev->cache = NULL; + dev->gc_cleanup_list = NULL; - - if (!init_failed && - dev->nShortOpCaches > 0) { + if (!init_failed && dev->param.n_caches > 0) { int i; - __u8 *buf; - int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache); + void *buf; + int cache_bytes = + dev->param.n_caches * sizeof(struct yaffs_cache); - if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) { - dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES; - } + if (dev->param.n_caches > YAFFS_MAX_SHORT_OP_CACHES) + dev->param.n_caches = YAFFS_MAX_SHORT_OP_CACHES; - dev->srCache = YMALLOC(srCacheBytes); - buf = (__u8 *)dev->srCache; + dev->cache = kmalloc(cache_bytes, GFP_NOFS); - if(dev->srCache) - memset(dev->srCache,0,srCacheBytes); + buf = (u8 *) dev->cache; - for (i = 0; i < dev->nShortOpCaches && buf; i++) { - dev->srCache[i].object = NULL; - dev->srCache[i].lastUse = 0; - dev->srCache[i].dirty = 0; - dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk); + if (dev->cache) + memset(dev->cache, 0, cache_bytes); + + for (i = 0; i < dev->param.n_caches && buf; i++) { + dev->cache[i].object = NULL; + dev->cache[i].last_use = 0; + dev->cache[i].dirty = 0; + dev->cache[i].data = buf = + kmalloc(dev->param.total_bytes_per_chunk, GFP_NOFS); } - if(!buf) + if (!buf) init_failed = 1; - dev->srLastUse = 0; + dev->cache_last_use = 0; } - dev->cacheHits = 0; + dev->cache_hits = 0; - if(!init_failed){ - dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32)); - if(!dev->gcCleanupList) + if (!init_failed) { + dev->gc_cleanup_list = + kmalloc(dev->param.chunks_per_block * sizeof(u32), + GFP_NOFS); + if (!dev->gc_cleanup_list) init_failed = 1; } - if (dev->isYaffs2) { - dev->useHeaderFileSize = 1; - } - if(!init_failed && !yaffs_InitialiseBlocks(dev)) + if (dev->param.is_yaffs2) + dev->param.use_header_file_size = 1; + + if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; - yaffs_InitialiseTnodes(dev); - yaffs_InitialiseObjects(dev); + yaffs_init_tnodes_and_objs(dev); - if(!init_failed && !yaffs_CreateInitialDirectories(dev)) + if (!init_failed && !yaffs_create_initial_dir(dev)) init_failed = 1; + if (!init_failed && dev->param.is_yaffs2 && + !dev->param.disable_summary && + !yaffs_summary_init(dev)) + init_failed = 1; - if(!init_failed){ + if (!init_failed) { /* Now scan the flash. */ - if (dev->isYaffs2) { - if(yaffs_CheckpointRestore(dev)) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("yaffs: restored from checkpoint" TENDSTR))); + if (dev->param.is_yaffs2) { + if (yaffs2_checkpt_restore(dev)) { + yaffs_check_obj_details_loaded(dev->root_dir); + yaffs_trace(YAFFS_TRACE_CHECKPOINT | + YAFFS_TRACE_MOUNT, + "yaffs: restored from checkpoint" + ); } else { - /* Clean up the mess caused by an aborted checkpoint load - * and scan backwards. + /* Clean up the mess caused by an aborted + * checkpoint load then scan backwards. */ - yaffs_DeinitialiseBlocks(dev); - yaffs_DeinitialiseTnodes(dev); - yaffs_DeinitialiseObjects(dev); + yaffs_deinit_blocks(dev); + yaffs_deinit_tnodes_and_objs(dev); - dev->nErasedBlocks = 0; - dev->nFreeChunks = 0; - dev->allocationBlock = -1; - dev->allocationPage = -1; - dev->nDeletedFiles = 0; - dev->nUnlinkedFiles = 0; - dev->nBackgroundDeletions = 0; - dev->oldestDirtySequence = 0; + dev->n_erased_blocks = 0; + dev->n_free_chunks = 0; + dev->alloc_block = -1; + dev->alloc_page = -1; + dev->n_deleted_files = 0; + dev->n_unlinked_files = 0; + dev->n_bg_deletions = 0; - if(!init_failed && !yaffs_InitialiseBlocks(dev)) + if (!init_failed && !yaffs_init_blocks(dev)) init_failed = 1; - yaffs_InitialiseTnodes(dev); - yaffs_InitialiseObjects(dev); + yaffs_init_tnodes_and_objs(dev); - if(!init_failed && !yaffs_CreateInitialDirectories(dev)) + if (!init_failed + && !yaffs_create_initial_dir(dev)) init_failed = 1; - if(!init_failed && !yaffs_ScanBackwards(dev)) + if (!init_failed && !yaffs2_scan_backwards(dev)) init_failed = 1; } - }else - if(!yaffs_Scan(dev)) - init_failed = 1; + } else if (!yaffs1_scan(dev)) { + init_failed = 1; + } + + yaffs_strip_deleted_objs(dev); + yaffs_fix_hanging_objs(dev); + if (dev->param.empty_lost_n_found) + yaffs_empty_l_n_f(dev); } - if(init_failed){ + if (init_failed) { /* Clean up the mess */ - T(YAFFS_TRACE_TRACING, - (TSTR("yaffs: yaffs_GutsInitialise() aborted.\n" TENDSTR))); + yaffs_trace(YAFFS_TRACE_TRACING, + "yaffs: yaffs_guts_initialise() aborted."); - yaffs_Deinitialise(dev); + yaffs_deinitialise(dev); return YAFFS_FAIL; } /* Zero out stats */ - dev->nPageReads = 0; - dev->nPageWrites = 0; - dev->nBlockErasures = 0; - dev->nGCCopies = 0; - dev->nRetriedWrites = 0; + dev->n_page_reads = 0; + dev->n_page_writes = 0; + dev->n_erasures = 0; + dev->n_gc_copies = 0; + dev->n_retried_writes = 0; - dev->nRetiredBlocks = 0; + dev->n_retired_blocks = 0; - yaffs_VerifyFreeChunks(dev); - yaffs_VerifyBlocks(dev); + yaffs_verify_free_chunks(dev); + yaffs_verify_blocks(dev); + /* Clean up any aborted checkpoint data */ + if (!dev->is_checkpointed && dev->blocks_in_checkpt > 0) + yaffs2_checkpt_invalidate(dev); - T(YAFFS_TRACE_TRACING, - (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR))); + yaffs_trace(YAFFS_TRACE_TRACING, + "yaffs: yaffs_guts_initialise() done."); return YAFFS_OK; - } -void yaffs_Deinitialise(yaffs_Device * dev) +void yaffs_deinitialise(struct yaffs_dev *dev) { - if (dev->isMounted) { + if (dev->is_mounted) { int i; - yaffs_DeinitialiseBlocks(dev); - yaffs_DeinitialiseTnodes(dev); - yaffs_DeinitialiseObjects(dev); - if (dev->nShortOpCaches > 0 && - dev->srCache) { + yaffs_deinit_blocks(dev); + yaffs_deinit_tnodes_and_objs(dev); + yaffs_summary_deinit(dev); + + if (dev->param.n_caches > 0 && dev->cache) { - for (i = 0; i < dev->nShortOpCaches; i++) { - if(dev->srCache[i].data) - YFREE(dev->srCache[i].data); - dev->srCache[i].data = NULL; + for (i = 0; i < dev->param.n_caches; i++) { + kfree(dev->cache[i].data); + dev->cache[i].data = NULL; } - YFREE(dev->srCache); - dev->srCache = NULL; + kfree(dev->cache); + dev->cache = NULL; } - YFREE(dev->gcCleanupList); + kfree(dev->gc_cleanup_list); - for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) { - YFREE(dev->tempBuffer[i].buffer); - } + for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) + kfree(dev->temp_buffer[i].buffer); - dev->isMounted = 0; - } + dev->is_mounted = 0; + if (dev->param.deinitialise_flash_fn) + dev->param.deinitialise_flash_fn(dev); + } } -static int yaffs_CountFreeChunks(yaffs_Device * dev) +int yaffs_count_free_chunks(struct yaffs_dev *dev) { - int nFree; + int n_free = 0; int b; + struct yaffs_block_info *blk; - yaffs_BlockInfo *blk; - - for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock; - b++) { - blk = yaffs_GetBlockInfo(dev, b); - - switch (blk->blockState) { + blk = dev->block_info; + for (b = dev->internal_start_block; b <= dev->internal_end_block; b++) { + switch (blk->block_state) { case YAFFS_BLOCK_STATE_EMPTY: case YAFFS_BLOCK_STATE_ALLOCATING: case YAFFS_BLOCK_STATE_COLLECTING: case YAFFS_BLOCK_STATE_FULL: - nFree += - (dev->nChunksPerBlock - blk->pagesInUse + - blk->softDeletions); + n_free += + (dev->param.chunks_per_block - blk->pages_in_use + + blk->soft_del_pages); break; default: break; } - + blk++; } - - return nFree; + return n_free; } -int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev) +int yaffs_get_n_free_chunks(struct yaffs_dev *dev) { /* This is what we report to the outside world */ + int n_free; + int n_dirty_caches; + int blocks_for_checkpt; + int i; - int nFree; - int nDirtyCacheChunks; - int blocksForCheckpoint; - -#if 1 - nFree = dev->nFreeChunks; -#else - nFree = yaffs_CountFreeChunks(dev); -#endif - - nFree += dev->nDeletedFiles; + n_free = dev->n_free_chunks; + n_free += dev->n_deleted_files; - /* Now count the number of dirty chunks in the cache and subtract those */ + /* Now count and subtract the number of dirty chunks in the cache. */ - { - int i; - for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) { - if (dev->srCache[i].dirty) - nDirtyCacheChunks++; - } + for (n_dirty_caches = 0, i = 0; i < dev->param.n_caches; i++) { + if (dev->cache[i].dirty) + n_dirty_caches++; } - nFree -= nDirtyCacheChunks; - - nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock); + n_free -= n_dirty_caches; - /* Now we figure out how much to reserve for the checkpoint and report that... */ - blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint; - if(blocksForCheckpoint < 0) - blocksForCheckpoint = 0; + n_free -= + ((dev->param.n_reserved_blocks + 1) * dev->param.chunks_per_block); - nFree -= (blocksForCheckpoint * dev->nChunksPerBlock); + /* Now figure checkpoint space and report that... */ + blocks_for_checkpt = yaffs_calc_checkpt_blocks_required(dev); - if (nFree < 0) - nFree = 0; + n_free -= (blocks_for_checkpt * dev->param.chunks_per_block); - return nFree; + if (n_free < 0) + n_free = 0; + return n_free; } -static int yaffs_freeVerificationFailures; - -static void yaffs_VerifyFreeChunks(yaffs_Device * dev) +/*\ + * Marshalling functions to get loff_t file sizes into aand out of + * object headers. + */ +void yaffs_oh_size_load(struct yaffs_obj_hdr *oh, loff_t fsize) { - int counted; - int difference; - - if(yaffs_SkipVerification(dev)) - return; - - counted = yaffs_CountFreeChunks(dev); - - difference = dev->nFreeChunks - counted; - - if (difference) { - T(YAFFS_TRACE_ALWAYS, - (TSTR("Freechunks verification failure %d %d %d" TENDSTR), - dev->nFreeChunks, counted, difference)); - yaffs_freeVerificationFailures++; - } + oh->file_size_low = (fsize & 0xFFFFFFFF); + oh->file_size_high = ((fsize >> 32) & 0xFFFFFFFF); } -/*---------------------------------------- YAFFS test code ----------------------*/ - -#define yaffs_CheckStruct(structure,syze, name) \ - if(sizeof(structure) != syze) \ - { \ - T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\ - name,syze,sizeof(structure))); \ - return YAFFS_FAIL; \ - } - -static int yaffs_CheckStructures(void) +loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh) { -/* yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */ -/* yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */ -/* yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */ -#ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG - yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode") -#endif - yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader") + loff_t retval; + + if (~(oh->file_size_high)) + retval = (((loff_t) oh->file_size_high) << 32) | + (((loff_t) oh->file_size_low) & 0xFFFFFFFF); + else + retval = (loff_t) oh->file_size_low; - return YAFFS_OK; + return retval; } diff --git a/fs/yaffs2/yaffs_guts.h b/fs/yaffs2/yaffs_guts.h index 1f75efd..e3558c5 100644 --- a/fs/yaffs2/yaffs_guts.h +++ b/fs/yaffs2/yaffs_guts.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -16,7 +16,6 @@ #ifndef __YAFFS_GUTS_H__ #define __YAFFS_GUTS_H__ -#include "devextras.h" #include "yportenv.h" #define YAFFS_OK 1 @@ -24,35 +23,48 @@ /* Give us a Y=0x59, * Give us an A=0x41, - * Give us an FF=0xFF + * Give us an FF=0xff * Give us an S=0x53 * And what have we got... */ -#define YAFFS_MAGIC 0x5941FF53 +#define YAFFS_MAGIC 0x5941ff53 -#define YAFFS_NTNODES_LEVEL0 16 +/* + * Tnodes form a tree with the tnodes in "levels" + * Levels greater than 0 hold 8 slots which point to other tnodes. + * Those at level 0 hold 16 slots which point to chunks in NAND. + * + * A maximum level of 8 thust supports files of size up to: + * + * 2^(3*MAX_LEVEL+4) + * + * Thus a max level of 8 supports files with up to 2^^28 chunks which gives + * a maximum file size of arounf 51Gbytees with 2k chunks. + */ +#define YAFFS_NTNODES_LEVEL0 16 #define YAFFS_TNODES_LEVEL0_BITS 4 #define YAFFS_TNODES_LEVEL0_MASK 0xf -#define YAFFS_NTNODES_INTERNAL (YAFFS_NTNODES_LEVEL0 / 2) -#define YAFFS_TNODES_INTERNAL_BITS (YAFFS_TNODES_LEVEL0_BITS - 1) +#define YAFFS_NTNODES_INTERNAL (YAFFS_NTNODES_LEVEL0 / 2) +#define YAFFS_TNODES_INTERNAL_BITS (YAFFS_TNODES_LEVEL0_BITS - 1) #define YAFFS_TNODES_INTERNAL_MASK 0x7 -#define YAFFS_TNODES_MAX_LEVEL 6 +#define YAFFS_TNODES_MAX_LEVEL 8 +#define YAFFS_TNODES_MAX_BITS (YAFFS_TNODES_LEVEL0_BITS + \ + YAFFS_TNODES_INTERNAL_BITS * \ + YAFFS_TNODES_MAX_LEVEL) +#define YAFFS_MAX_CHUNK_ID ((1 << YAFFS_TNODES_MAX_BITS) - 1) -#ifndef CONFIG_YAFFS_NO_YAFFS1 +/* Constants for YAFFS1 mode */ #define YAFFS_BYTES_PER_SPARE 16 #define YAFFS_BYTES_PER_CHUNK 512 #define YAFFS_CHUNK_SIZE_SHIFT 9 #define YAFFS_CHUNKS_PER_BLOCK 32 -#define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK) -#endif +#define YAFFS_BYTES_PER_BLOCK (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK) -#define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024 +#define YAFFS_MIN_YAFFS2_CHUNK_SIZE 1024 #define YAFFS_MIN_YAFFS2_SPARE_SIZE 32 -#define YAFFS_MAX_CHUNK_ID 0x000FFFFF -#define YAFFS_UNUSED_OBJECT_ID 0x0003FFFF #define YAFFS_ALLOCATION_NOBJECTS 100 #define YAFFS_ALLOCATION_NTNODES 100 @@ -60,10 +72,12 @@ #define YAFFS_NOBJECT_BUCKETS 256 - #define YAFFS_OBJECT_SPACE 0x40000 +#define YAFFS_MAX_OBJECT_ID (YAFFS_OBJECT_SPACE - 1) -#define YAFFS_CHECKPOINT_VERSION 3 +/* Binary data version stamps */ +#define YAFFS_SUMMARY_VERSION 1 +#define YAFFS_CHECKPOINT_VERSION 6 #ifdef CONFIG_YAFFS_UNICODE #define YAFFS_MAX_NAME_LENGTH 127 @@ -81,16 +95,16 @@ #define YAFFS_OBJECTID_UNLINKED 3 #define YAFFS_OBJECTID_DELETED 4 -/* Sseudo object ids for checkpointing */ -#define YAFFS_OBJECTID_SB_HEADER 0x10 -#define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 -#define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 +/* Fake object Id for summary data */ +#define YAFFS_OBJECTID_SUMMARY 0x10 -/* */ +/* Pseudo object ids for checkpointing */ +#define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20 +#define YAFFS_SEQUENCE_CHECKPOINT_DATA 0x21 #define YAFFS_MAX_SHORT_OP_CACHES 20 -#define YAFFS_N_TEMP_BUFFERS 4 +#define YAFFS_N_TEMP_BUFFERS 6 /* We limit the number attempts at sucessfully saving a chunk of data. * Small-page devices have 32 pages per block; large-page devices have 64. @@ -102,142 +116,136 @@ * The range is limited slightly to help distinguish bad numbers from good. * This also allows us to perhaps in the future use special numbers for * special purposes. - * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years, + * EFFFFF00 allows the allocation of 8 blocks/second (~1Mbytes) for 15 years, * and is a larger number than the lifetime of a 2GB device. */ #define YAFFS_LOWEST_SEQUENCE_NUMBER 0x00001000 -#define YAFFS_HIGHEST_SEQUENCE_NUMBER 0xEFFFFF00 +#define YAFFS_HIGHEST_SEQUENCE_NUMBER 0xefffff00 + +/* Special sequence number for bad block that failed to be marked bad */ +#define YAFFS_SEQUENCE_BAD_BLOCK 0xffff0000 /* ChunkCache is used for short read/write operations.*/ -typedef struct { - struct yaffs_ObjectStruct *object; - int chunkId; - int lastUse; +struct yaffs_cache { + struct yaffs_obj *object; + int chunk_id; + int last_use; int dirty; - int nBytes; /* Only valid if the cache is dirty */ + int n_bytes; /* Only valid if the cache is dirty */ int locked; /* Can't push out or flush while locked. */ -#ifdef CONFIG_YAFFS_YAFFS2 - __u8 *data; -#else - __u8 data[YAFFS_BYTES_PER_CHUNK]; -#endif -} yaffs_ChunkCache; - - + u8 *data; +}; -/* Tags structures in RAM - * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise - * the structure size will get blown out. +/* yaffs1 tags structures in RAM + * NB This uses bitfield. Bitfields should not straddle a u32 boundary + * otherwise the structure size will get blown out. */ -#ifndef CONFIG_YAFFS_NO_YAFFS1 -typedef struct { - unsigned chunkId:20; - unsigned serialNumber:2; - unsigned byteCount:10; - unsigned objectId:18; +struct yaffs_tags { + unsigned chunk_id:20; + unsigned serial_number:2; + unsigned n_bytes_lsb:10; + unsigned obj_id:18; unsigned ecc:12; - unsigned unusedStuff:2; - -} yaffs_Tags; + unsigned n_bytes_msb:2; +}; -typedef union { - yaffs_Tags asTags; - __u8 asBytes[8]; -} yaffs_TagsUnion; +union yaffs_tags_union { + struct yaffs_tags as_tags; + u8 as_bytes[8]; +}; -#endif /* Stuff used for extended tags in YAFFS2 */ -typedef enum { +enum yaffs_ecc_result { YAFFS_ECC_RESULT_UNKNOWN, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_ECC_RESULT_FIXED, YAFFS_ECC_RESULT_UNFIXED -} yaffs_ECCResult; +}; -typedef enum { +enum yaffs_obj_type { YAFFS_OBJECT_TYPE_UNKNOWN, YAFFS_OBJECT_TYPE_FILE, YAFFS_OBJECT_TYPE_SYMLINK, YAFFS_OBJECT_TYPE_DIRECTORY, YAFFS_OBJECT_TYPE_HARDLINK, YAFFS_OBJECT_TYPE_SPECIAL -} yaffs_ObjectType; +}; #define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL -typedef struct { - - unsigned validMarker0; - unsigned chunkUsed; /* Status of the chunk: used or unused */ - unsigned objectId; /* If 0 then this is not part of an object (unused) */ - unsigned chunkId; /* If 0 then this is a header, else a data chunk */ - unsigned byteCount; /* Only valid for data chunks */ +struct yaffs_ext_tags { + unsigned chunk_used; /* Status of the chunk: used or unused */ + unsigned obj_id; /* If 0 this is not used */ + unsigned chunk_id; /* If 0 this is a header, else a data chunk */ + unsigned n_bytes; /* Only valid for data chunks */ /* The following stuff only has meaning when we read */ - yaffs_ECCResult eccResult; - unsigned blockBad; + enum yaffs_ecc_result ecc_result; + unsigned block_bad; /* YAFFS 1 stuff */ - unsigned chunkDeleted; /* The chunk is marked deleted */ - unsigned serialNumber; /* Yaffs1 2-bit serial number */ + unsigned is_deleted; /* The chunk is marked deleted */ + unsigned serial_number; /* Yaffs1 2-bit serial number */ /* YAFFS2 stuff */ - unsigned sequenceNumber; /* The sequence number of this block */ + unsigned seq_number; /* The sequence number of this block */ /* Extra info if this is an object header (YAFFS2 only) */ - unsigned extraHeaderInfoAvailable; /* There is extra info available if this is not zero */ - unsigned extraParentObjectId; /* The parent object */ - unsigned extraIsShrinkHeader; /* Is it a shrink header? */ - unsigned extraShadows; /* Does this shadow another object? */ - - yaffs_ObjectType extraObjectType; /* What object type? */ + unsigned extra_available; /* Extra info available if not zero */ + unsigned extra_parent_id; /* The parent object */ + unsigned extra_is_shrink; /* Is it a shrink header? */ + unsigned extra_shadows; /* Does this shadow another object? */ - unsigned extraFileLength; /* Length if it is a file */ - unsigned extraEquivalentObjectId; /* Equivalent object Id if it is a hard link */ + enum yaffs_obj_type extra_obj_type; /* What object type? */ - unsigned validMarker1; - -} yaffs_ExtendedTags; + loff_t extra_file_size; /* Length if it is a file */ + unsigned extra_equiv_id; /* Equivalent object for a hard link */ +}; /* Spare structure for YAFFS1 */ -typedef struct { - __u8 tagByte0; - __u8 tagByte1; - __u8 tagByte2; - __u8 tagByte3; - __u8 pageStatus; /* set to 0 to delete the chunk */ - __u8 blockStatus; - __u8 tagByte4; - __u8 tagByte5; - __u8 ecc1[3]; - __u8 tagByte6; - __u8 tagByte7; - __u8 ecc2[3]; -} yaffs_Spare; +struct yaffs_spare { + u8 tb0; + u8 tb1; + u8 tb2; + u8 tb3; + u8 page_status; /* set to 0 to delete the chunk */ + u8 block_status; + u8 tb4; + u8 tb5; + u8 ecc1[3]; + u8 tb6; + u8 tb7; + u8 ecc2[3]; +}; /*Special structure for passing through to mtd */ -struct yaffs_NANDSpare { - yaffs_Spare spare; +struct yaffs_nand_spare { + struct yaffs_spare spare; int eccres1; int eccres2; }; /* Block data in RAM */ -typedef enum { +enum yaffs_block_state { YAFFS_BLOCK_STATE_UNKNOWN = 0, YAFFS_BLOCK_STATE_SCANNING, - YAFFS_BLOCK_STATE_NEEDS_SCANNING, - /* The block might have something on it (ie it is allocating or full, perhaps empty) - * but it needs to be scanned to determine its true state. - * This state is only valid during yaffs_Scan. - * NB We tolerate empty because the pre-scanner might be incapable of deciding - * However, if this state is returned on a YAFFS2 device, then we expect a sequence number + /* Being scanned */ + + YAFFS_BLOCK_STATE_NEEDS_SCAN, + /* The block might have something on it (ie it is allocating or full, + * perhaps empty) but it needs to be scanned to determine its true + * state. + * This state is only valid during scanning. + * NB We tolerate empty because the pre-scanner might be incapable of + * deciding + * However, if this state is returned on a YAFFS2 device, + * then we expect a sequence number */ YAFFS_BLOCK_STATE_EMPTY, @@ -247,123 +255,109 @@ typedef enum { /* This block is partially allocated. * At least one page holds valid data. * This is the one currently being used for page - * allocation. Should never be more than one of these + * allocation. Should never be more than one of these. + * If a block is only partially allocated at mount it is treated as + * full. */ YAFFS_BLOCK_STATE_FULL, /* All the pages in this block have been allocated. + * If a block was only partially allocated when mounted we treat + * it as fully allocated. */ YAFFS_BLOCK_STATE_DIRTY, - /* All pages have been allocated and deleted. + /* The block was full and now all chunks have been deleted. * Erase me, reuse me. */ YAFFS_BLOCK_STATE_CHECKPOINT, - /* This block is assigned to holding checkpoint data. - */ + /* This block is assigned to holding checkpoint data. */ YAFFS_BLOCK_STATE_COLLECTING, /* This block is being garbage collected */ YAFFS_BLOCK_STATE_DEAD - /* This block has failed and is not in use */ -} yaffs_BlockState; + /* This block has failed and is not in use */ +}; #define YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1) +struct yaffs_block_info { + + int soft_del_pages:10; /* number of soft deleted pages */ + int pages_in_use:10; /* number of pages in use */ + unsigned block_state:4; /* One of the above block states. */ + /* NB use unsigned because enum is sometimes + * an int */ + u32 needs_retiring:1; /* Data has failed on this block, */ + /*need to get valid data off and retire*/ + u32 skip_erased_check:1;/* Skip the erased check on this block */ + u32 gc_prioritise:1; /* An ECC check or blank check has failed. + Block should be prioritised for GC */ + u32 chunk_error_strikes:3; /* How many times we've had ecc etc + failures on this block and tried to reuse it */ + u32 has_summary:1; /* The block has a summary */ + + u32 has_shrink_hdr:1; /* This block has at least one shrink header */ + u32 seq_number; /* block sequence number for yaffs2 */ -typedef struct { - - int softDeletions:10; /* number of soft deleted pages */ - int pagesInUse:10; /* number of pages in use */ - unsigned blockState:4; /* One of the above block states. NB use unsigned because enum is sometimes an int */ - __u32 needsRetiring:1; /* Data has failed on this block, need to get valid data off */ - /* and retire the block. */ - __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */ - __u32 gcPrioritise: 1; /* An ECC check or blank check has failed on this block. - It should be prioritised for GC */ - __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */ - -#ifdef CONFIG_YAFFS_YAFFS2 - __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */ - __u32 sequenceNumber; /* block sequence number for yaffs2 */ -#endif - -} yaffs_BlockInfo; +}; /* -------------------------- Object structure -------------------------------*/ /* This is the object structure as stored on NAND */ -typedef struct { - yaffs_ObjectType type; +struct yaffs_obj_hdr { + enum yaffs_obj_type type; /* Apply to everything */ - int parentObjectId; - __u16 sum__NoLongerUsed; /* checksum of name. No longer used */ + int parent_obj_id; + u16 sum_no_longer_used; /* checksum of name. No longer used */ YCHAR name[YAFFS_MAX_NAME_LENGTH + 1]; - /* Thes following apply to directories, files, symlinks - not hard links */ - __u32 yst_mode; /* protection */ + /* The following apply to all object types except for hard links */ + u32 yst_mode; /* protection */ -#ifdef CONFIG_YAFFS_WINCE - __u32 notForWinCE[5]; -#else - __u32 yst_uid; - __u32 yst_gid; - __u32 yst_atime; - __u32 yst_mtime; - __u32 yst_ctime; -#endif + u32 yst_uid; + u32 yst_gid; + u32 yst_atime; + u32 yst_mtime; + u32 yst_ctime; /* File size applies to files only */ - int fileSize; + u32 file_size_low; /* Equivalent object id applies to hard links only. */ - int equivalentObjectId; + int equiv_id; /* Alias is for symlinks only. */ YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1]; - __u32 yst_rdev; /* device stuff for block and char devices (major/min) */ + u32 yst_rdev; /* stuff for block and char devices (major/min) */ -#ifdef CONFIG_YAFFS_WINCE - __u32 win_ctime[2]; - __u32 win_atime[2]; - __u32 win_mtime[2]; - __u32 roomToGrow[4]; -#else - __u32 roomToGrow[10]; -#endif - - int shadowsObject; /* This object header shadows the specified object if > 0 */ + u32 win_ctime[2]; + u32 win_atime[2]; + u32 win_mtime[2]; - /* isShrink applies to object headers written when we shrink the file (ie resize) */ - __u32 isShrink; + u32 inband_shadowed_obj_id; + u32 inband_is_shrink; -} yaffs_ObjectHeader; + u32 file_size_high; + u32 reserved[1]; + int shadows_obj; /* This object header shadows the + specified object if > 0 */ -/*--------------------------- Tnode -------------------------- */ - -union yaffs_Tnode_union { -#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG - union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL + 1]; -#else - union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL]; -#endif -/* __u16 level0[YAFFS_NTNODES_LEVEL0]; */ + /* is_shrink applies to object headers written when wemake a hole. */ + u32 is_shrink; }; -typedef union yaffs_Tnode_union yaffs_Tnode; +/*--------------------------- Tnode -------------------------- */ -struct yaffs_TnodeList_struct { - struct yaffs_TnodeList_struct *next; - yaffs_Tnode *tnodes; +struct yaffs_tnode { + struct yaffs_tnode *internal[YAFFS_NTNODES_INTERNAL]; }; -typedef struct yaffs_TnodeList_struct yaffs_TnodeList; - /*------------------------ Object -----------------------------*/ /* An object can be one of: * - a directory (no data, has children links @@ -372,537 +366,608 @@ typedef struct yaffs_TnodeList_struct yaffs_TnodeList; * - a hard link */ -typedef struct { - __u32 fileSize; - __u32 scannedFileSize; - __u32 shrinkSize; - int topLevel; - yaffs_Tnode *top; -} yaffs_FileStructure; +struct yaffs_file_var { + loff_t file_size; + loff_t scanned_size; + loff_t shrink_size; + int top_level; + struct yaffs_tnode *top; +}; -typedef struct { +struct yaffs_dir_var { struct list_head children; /* list of child links */ -} yaffs_DirectoryStructure; + struct list_head dirty; /* Entry for list of dirty directories */ +}; -typedef struct { +struct yaffs_symlink_var { YCHAR *alias; -} yaffs_SymLinkStructure; - -typedef struct { - struct yaffs_ObjectStruct *equivalentObject; - __u32 equivalentObjectId; -} yaffs_HardLinkStructure; - -typedef union { - yaffs_FileStructure fileVariant; - yaffs_DirectoryStructure directoryVariant; - yaffs_SymLinkStructure symLinkVariant; - yaffs_HardLinkStructure hardLinkVariant; -} yaffs_ObjectVariant; - -struct yaffs_ObjectStruct { - __u8 deleted:1; /* This should only apply to unlinked files. */ - __u8 softDeleted:1; /* it has also been soft deleted */ - __u8 unlinked:1; /* An unlinked file. The file should be in the unlinked directory.*/ - __u8 fake:1; /* A fake object has no presence on NAND. */ - __u8 renameAllowed:1; /* Some objects are not allowed to be renamed. */ - __u8 unlinkAllowed:1; - __u8 dirty:1; /* the object needs to be written to flash */ - __u8 valid:1; /* When the file system is being loaded up, this +}; + +struct yaffs_hardlink_var { + struct yaffs_obj *equiv_obj; + u32 equiv_id; +}; + +union yaffs_obj_var { + struct yaffs_file_var file_variant; + struct yaffs_dir_var dir_variant; + struct yaffs_symlink_var symlink_variant; + struct yaffs_hardlink_var hardlink_variant; +}; + +struct yaffs_obj { + u8 deleted:1; /* This should only apply to unlinked files. */ + u8 soft_del:1; /* it has also been soft deleted */ + u8 unlinked:1; /* An unlinked file.*/ + u8 fake:1; /* A fake object has no presence on NAND. */ + u8 rename_allowed:1; /* Some objects cannot be renamed. */ + u8 unlink_allowed:1; + u8 dirty:1; /* the object needs to be written to flash */ + u8 valid:1; /* When the file system is being loaded up, this * object might be created before the data - * is available (ie. file data records appear before the header). + * is available + * ie. file data chunks encountered before + * the header. */ - __u8 lazyLoaded:1; /* This object has been lazy loaded and is missing some detail */ + u8 lazy_loaded:1; /* This object has been lazy loaded and + * is missing some detail */ - __u8 deferedFree:1; /* For Linux kernel. Object is removed from NAND, but is - * still in the inode cache. Free of object is defered. + u8 defered_free:1; /* Object is removed from NAND, but is + * still in the inode cache. + * Free of object is defered. * until the inode is released. */ + u8 being_created:1; /* This object is still being created + * so skip some verification checks. */ + u8 is_shadowed:1; /* This object is shadowed on the way + * to being renamed. */ - __u8 serial; /* serial number of chunk in NAND. Cached here */ - __u16 sum; /* sum of the name to speed searching */ + u8 xattr_known:1; /* We know if this has object has xattribs + * or not. */ + u8 has_xattr:1; /* This object has xattribs. + * Only valid if xattr_known. */ - struct yaffs_DeviceStruct *myDev; /* The device I'm on */ + u8 serial; /* serial number of chunk in NAND.*/ + u16 sum; /* sum of the name to speed searching */ - struct list_head hashLink; /* list of objects in this hash bucket */ + struct yaffs_dev *my_dev; /* The device I'm on */ - struct list_head hardLinks; /* all the equivalent hard linked objects */ + struct list_head hash_link; /* list of objects in hash bucket */ + + struct list_head hard_links; /* hard linked object chain*/ /* directory structure stuff */ /* also used for linking up the free list */ - struct yaffs_ObjectStruct *parent; + struct yaffs_obj *parent; struct list_head siblings; /* Where's my object header in NAND? */ - int chunkId; + int hdr_chunk; - int nDataChunks; /* Number of data chunks attached to the file. */ + int n_data_chunks; /* Number of data chunks for this file. */ - __u32 objectId; /* the object id value */ + u32 obj_id; /* the object id value */ - __u32 yst_mode; + u32 yst_mode; -#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM - YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1]; -#endif - -/* XXX U-BOOT XXX */ -/* #ifndef __KERNEL__ */ - __u32 inUse; -/* #endif */ + YCHAR short_name[YAFFS_SHORT_NAME_LENGTH + 1]; #ifdef CONFIG_YAFFS_WINCE - __u32 win_ctime[2]; - __u32 win_mtime[2]; - __u32 win_atime[2]; + u32 win_ctime[2]; + u32 win_mtime[2]; + u32 win_atime[2]; #else - __u32 yst_uid; - __u32 yst_gid; - __u32 yst_atime; - __u32 yst_mtime; - __u32 yst_ctime; + u32 yst_uid; + u32 yst_gid; + u32 yst_atime; + u32 yst_mtime; + u32 yst_ctime; #endif - __u32 yst_rdev; + u32 yst_rdev; -/* XXX U-BOOT XXX */ -/* #ifndef __KERNEL__ */ - struct inode *myInode; -/* #endif */ + void *my_inode; - yaffs_ObjectType variantType; + enum yaffs_obj_type variant_type; - yaffs_ObjectVariant variant; + union yaffs_obj_var variant; }; -typedef struct yaffs_ObjectStruct yaffs_Object; - -struct yaffs_ObjectList_struct { - yaffs_Object *objects; - struct yaffs_ObjectList_struct *next; -}; - -typedef struct yaffs_ObjectList_struct yaffs_ObjectList; - -typedef struct { +struct yaffs_obj_bucket { struct list_head list; int count; -} yaffs_ObjectBucket; - +}; -/* yaffs_CheckpointObject holds the definition of an object as dumped +/* yaffs_checkpt_obj holds the definition of an object as dumped * by checkpointing. */ -typedef struct { - int structType; - __u32 objectId; - __u32 parentId; - int chunkId; - - yaffs_ObjectType variantType:3; - __u8 deleted:1; - __u8 softDeleted:1; - __u8 unlinked:1; - __u8 fake:1; - __u8 renameAllowed:1; - __u8 unlinkAllowed:1; - __u8 serial; - - int nDataChunks; - __u32 fileSizeOrEquivalentObjectId; - -}yaffs_CheckpointObject; +struct yaffs_checkpt_obj { + int struct_type; + u32 obj_id; + u32 parent_id; + int hdr_chunk; + enum yaffs_obj_type variant_type:3; + u8 deleted:1; + u8 soft_del:1; + u8 unlinked:1; + u8 fake:1; + u8 rename_allowed:1; + u8 unlink_allowed:1; + u8 serial; + int n_data_chunks; + loff_t size_or_equiv_obj; +}; /*--------------------- Temporary buffers ---------------- * - * These are chunk-sized working buffers. Each device has a few + * These are chunk-sized working buffers. Each device has a few. */ -typedef struct { - __u8 *buffer; - int line; /* track from whence this buffer was allocated */ - int maxLine; -} yaffs_TempBuffer; +struct yaffs_buffer { + u8 *buffer; + int in_use; +}; /*----------------- Device ---------------------------------*/ -struct yaffs_DeviceStruct { - struct list_head devList; - const char *name; - - /* Entry parameters set up way early. Yaffs sets up the rest.*/ - int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */ - int nChunksPerBlock; /* does not need to be a power of 2 */ - int nBytesPerSpare; /* spare area size */ - int startBlock; /* Start block we're allowed to use */ - int endBlock; /* End block we're allowed to use */ - int nReservedBlocks; /* We want this tuneable so that we can reduce */ - /* reserved blocks on NOR and RAM. */ - - - /* Stuff used by the shared space checkpointing mechanism */ - /* If this value is zero, then this mechanism is disabled */ - - int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */ - - +struct yaffs_param { + const YCHAR *name; + /* + * Entry parameters set up way early. Yaffs sets up the rest. + * The structure should be zeroed out before use so that unused + * and defualt values are zero. + */ - int nShortOpCaches; /* If <= 0, then short op caching is disabled, else - * the number of short op caches (don't use too many) + int inband_tags; /* Use unband tags */ + u32 total_bytes_per_chunk; /* Should be >= 512, does not need to + be a power of 2 */ + int chunks_per_block; /* does not need to be a power of 2 */ + int spare_bytes_per_chunk; /* spare area size */ + int start_block; /* Start block we're allowed to use */ + int end_block; /* End block we're allowed to use */ + int n_reserved_blocks; /* Tuneable so that we can reduce + * reserved blocks on NOR and RAM. */ + + int n_caches; /* If <= 0, then short op caching is disabled, + * else the number of short op caches. */ + int use_nand_ecc; /* Flag to decide whether or not to use + * NAND driver ECC on data (yaffs1) */ + int tags_9bytes; /* Use 9 byte tags */ + int no_tags_ecc; /* Flag to decide whether or not to do ECC + * on packed tags (yaffs2) */ - int useHeaderFileSize; /* Flag to determine if we should use file sizes from the header */ - - int useNANDECC; /* Flag to decide whether or not to use NANDECC */ + int is_yaffs2; /* Use yaffs2 mode on this device */ - void *genericDevice; /* Pointer to device context - * On an mtd this holds the mtd pointer. - */ - void *superBlock; - - /* NAND access functions (Must be set before calling YAFFS)*/ - - int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev, - int chunkInNAND, const __u8 * data, - const yaffs_Spare * spare); - int (*readChunkFromNAND) (struct yaffs_DeviceStruct * dev, - int chunkInNAND, __u8 * data, - yaffs_Spare * spare); - int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev, - int blockInNAND); - int (*initialiseNAND) (struct yaffs_DeviceStruct * dev); - -#ifdef CONFIG_YAFFS_YAFFS2 - int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev, - int chunkInNAND, const __u8 * data, - const yaffs_ExtendedTags * tags); - int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct * dev, - int chunkInNAND, __u8 * data, - yaffs_ExtendedTags * tags); - int (*markNANDBlockBad) (struct yaffs_DeviceStruct * dev, int blockNo); - int (*queryNANDBlock) (struct yaffs_DeviceStruct * dev, int blockNo, - yaffs_BlockState * state, int *sequenceNumber); -#endif + int empty_lost_n_found; /* Auto-empty lost+found directory on mount */ - int isYaffs2; + int refresh_period; /* How often to check for a block refresh */ - /* The removeObjectCallback function must be supplied by OS flavours that - * need it. The Linux kernel does not use this, but yaffs direct does use - * it to implement the faster readdir + /* Checkpoint control. Can be set before or after initialisation */ + u8 skip_checkpt_rd; + u8 skip_checkpt_wr; + + int enable_xattr; /* Enable xattribs */ + + /* NAND access functions (Must be set before calling YAFFS) */ + + int (*write_chunk_fn) (struct yaffs_dev *dev, + int nand_chunk, const u8 *data, + const struct yaffs_spare *spare); + int (*read_chunk_fn) (struct yaffs_dev *dev, + int nand_chunk, u8 *data, + struct yaffs_spare *spare); + int (*erase_fn) (struct yaffs_dev *dev, int flash_block); + int (*initialise_flash_fn) (struct yaffs_dev *dev); + int (*deinitialise_flash_fn) (struct yaffs_dev *dev); + + /* yaffs2 mode functions */ + int (*write_chunk_tags_fn) (struct yaffs_dev *dev, + int nand_chunk, const u8 *data, + const struct yaffs_ext_tags *tags); + int (*read_chunk_tags_fn) (struct yaffs_dev *dev, + int nand_chunk, u8 *data, + struct yaffs_ext_tags *tags); + int (*bad_block_fn) (struct yaffs_dev *dev, int block_no); + int (*query_block_fn) (struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, + u32 *seq_number); + + /* The remove_obj_fn function must be supplied by OS flavours that + * need it. + * yaffs direct uses it to implement the faster readdir. + * Linux uses it to protect the directory during unlocking. */ - void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj); + void (*remove_obj_fn) (struct yaffs_obj *obj); - /* Callback to mark the superblock dirsty */ - void (*markSuperBlockDirty)(void * superblock); + /* Callback to mark the superblock dirty */ + void (*sb_dirty_fn) (struct yaffs_dev *dev); - int wideTnodesDisabled; /* Set to disable wide tnodes */ + /* Callback to control garbage collection. */ + unsigned (*gc_control) (struct yaffs_dev *dev); + /* Debug control flags. Don't use unless you know what you're doing */ + int use_header_file_size; /* Flag to determine if we should use + * file sizes from the header */ + int disable_lazy_load; /* Disable lazy loading on this device */ + int wide_tnodes_disabled; /* Set to disable wide tnodes */ + int disable_soft_del; /* yaffs 1 only: Set to disable the use of + * softdeletion. */ - /* End of stuff that must be set before initialisation. */ + int defered_dir_update; /* Set to defer directory updates */ - /* Checkpoint control. Can be set before or after initialisation */ - __u8 skipCheckpointRead; - __u8 skipCheckpointWrite; +#ifdef CONFIG_YAFFS_AUTO_UNICODE + int auto_unicode; +#endif + int always_check_erased; /* Force chunk erased check always on */ - /* Runtime parameters. Set up by YAFFS. */ + int disable_summary; - __u16 chunkGroupBits; /* 0 for devices <= 32MB. else log2(nchunks) - 16 */ - __u16 chunkGroupSize; /* == 2^^chunkGroupBits */ + int max_objects; /* + * Set to limit the number of objects created. + * 0 = no limit. + */ +}; - /* Stuff to support wide tnodes */ - __u32 tnodeWidth; - __u32 tnodeMask; +struct yaffs_dev { + struct yaffs_param param; - /* Stuff to support various file offses to chunk/offset translations */ - /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */ - __u32 crumbMask; - __u32 crumbShift; - __u32 crumbsPerChunk; + /* Context storage. Holds extra OS specific data for this device */ - /* Straight shifting for nDataBytesPerChunk being a power of 2 */ - __u32 chunkShift; - __u32 chunkMask; + void *os_context; + void *driver_context; + struct list_head dev_list; -/* XXX U-BOOT XXX */ -#if 0 -#ifndef __KERNEL__ + /* Runtime parameters. Set up by YAFFS. */ + int data_bytes_per_chunk; - struct semaphore sem; /* Semaphore for waiting on erasure.*/ - struct semaphore grossLock; /* Gross locking semaphore */ - void (*putSuperFunc) (struct super_block * sb); -#endif -#endif - __u8 *spareBuffer; /* For mtdif2 use. Don't know the size of the buffer - * at compile time so we have to allocate it. + /* Non-wide tnode stuff */ + u16 chunk_grp_bits; /* Number of bits that need to be resolved if + * the tnodes are not wide enough. */ + u16 chunk_grp_size; /* == 2^^chunk_grp_bits */ - int isMounted; + /* Stuff to support wide tnodes */ + u32 tnode_width; + u32 tnode_mask; + u32 tnode_size; - int isCheckpointed; + /* Stuff for figuring out file offset to chunk conversions */ + u32 chunk_shift; /* Shift value */ + u32 chunk_div; /* Divisor after shifting: 1 for 2^n sizes */ + u32 chunk_mask; /* Mask to use for power-of-2 case */ + int is_mounted; + int read_only; + int is_checkpointed; /* Stuff to support block offsetting to support start block zero */ - int internalStartBlock; - int internalEndBlock; - int blockOffset; - int chunkOffset; - + int internal_start_block; + int internal_end_block; + int block_offset; + int chunk_offset; /* Runtime checkpointing stuff */ - int checkpointPageSequence; /* running sequence number of checkpoint pages */ - int checkpointByteCount; - int checkpointByteOffset; - __u8 *checkpointBuffer; - int checkpointOpenForWrite; - int blocksInCheckpoint; - int checkpointCurrentChunk; - int checkpointCurrentBlock; - int checkpointNextBlock; - int *checkpointBlockList; - int checkpointMaxBlocks; - __u32 checkpointSum; - __u32 checkpointXor; + int checkpt_page_seq; /* running sequence number of checkpt pages */ + int checkpt_byte_count; + int checkpt_byte_offs; + u8 *checkpt_buffer; + int checkpt_open_write; + int blocks_in_checkpt; + int checkpt_cur_chunk; + int checkpt_cur_block; + int checkpt_next_block; + int *checkpt_block_list; + int checkpt_max_blocks; + u32 checkpt_sum; + u32 checkpt_xor; + + int checkpoint_blocks_required; /* Number of blocks needed to store + * current checkpoint set */ /* Block Info */ - yaffs_BlockInfo *blockInfo; - __u8 *chunkBits; /* bitmap of chunks in use */ - unsigned blockInfoAlt:1; /* was allocated using alternative strategy */ - unsigned chunkBitsAlt:1; /* was allocated using alternative strategy */ - int chunkBitmapStride; /* Number of bytes of chunkBits per block. - * Must be consistent with nChunksPerBlock. + struct yaffs_block_info *block_info; + u8 *chunk_bits; /* bitmap of chunks in use */ + unsigned block_info_alt:1; /* allocated using alternative alloc */ + unsigned chunk_bits_alt:1; /* allocated using alternative alloc */ + int chunk_bit_stride; /* Number of bytes of chunk_bits per block. + * Must be consistent with chunks_per_block. */ - int nErasedBlocks; - int allocationBlock; /* Current block being allocated off */ - __u32 allocationPage; - int allocationBlockFinder; /* Used to search for next allocation block */ - - /* Runtime state */ - int nTnodesCreated; - yaffs_Tnode *freeTnodes; - int nFreeTnodes; - yaffs_TnodeList *allocatedTnodeList; - - int isDoingGC; - - int nObjectsCreated; - yaffs_Object *freeObjects; - int nFreeObjects; + int n_erased_blocks; + int alloc_block; /* Current block being allocated off */ + u32 alloc_page; + int alloc_block_finder; /* Used to search for next allocation block */ - yaffs_ObjectList *allocatedObjectList; + /* Object and Tnode memory management */ + void *allocator; + int n_obj; + int n_tnodes; - yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS]; + int n_hardlinks; - int nFreeChunks; + struct yaffs_obj_bucket obj_bucket[YAFFS_NOBJECT_BUCKETS]; + u32 bucket_finder; - int currentDirtyChecker; /* Used to find current dirtiest block */ + int n_free_chunks; - __u32 *gcCleanupList; /* objects to delete at the end of a GC. */ - int nonAggressiveSkip; /* GC state/mode */ + /* Garbage collection control */ + u32 *gc_cleanup_list; /* objects to delete at the end of a GC. */ + u32 n_clean_ups; - /* Statistcs */ - int nPageWrites; - int nPageReads; - int nBlockErasures; - int nErasureFailures; - int nGCCopies; - int garbageCollections; - int passiveGarbageCollections; - int nRetriedWrites; - int nRetiredBlocks; - int eccFixed; - int eccUnfixed; - int tagsEccFixed; - int tagsEccUnfixed; - int nDeletions; - int nUnmarkedDeletions; - - int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */ + unsigned has_pending_prioritised_gc; /* We think this device might + have pending prioritised gcs */ + unsigned gc_disable; + unsigned gc_block_finder; + unsigned gc_dirtiest; + unsigned gc_pages_in_use; + unsigned gc_not_done; + unsigned gc_block; + unsigned gc_chunk; + unsigned gc_skip; + struct yaffs_summary_tags *gc_sum_tags; /* Special directories */ - yaffs_Object *rootDir; - yaffs_Object *lostNFoundDir; - - /* Buffer areas for storing data to recover from write failures TODO - * __u8 bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK]; - * yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK]; - */ - - int bufferedBlock; /* Which block is buffered here? */ - int doingBufferedBlockRewrite; + struct yaffs_obj *root_dir; + struct yaffs_obj *lost_n_found; + + int buffered_block; /* Which block is buffered here? */ + int doing_buffered_block_rewrite; + + struct yaffs_cache *cache; + int cache_last_use; + + /* Stuff for background deletion and unlinked files. */ + struct yaffs_obj *unlinked_dir; /* Directory where unlinked and deleted + files live. */ + struct yaffs_obj *del_dir; /* Directory where deleted objects are + sent to disappear. */ + struct yaffs_obj *unlinked_deletion; /* Current file being + background deleted. */ + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ + int n_bg_deletions; /* Count of background deletions. */ + + /* Temporary buffer management */ + struct yaffs_buffer temp_buffer[YAFFS_N_TEMP_BUFFERS]; + int max_temp; + int temp_in_use; + int unmanaged_buffer_allocs; + int unmanaged_buffer_deallocs; - yaffs_ChunkCache *srCache; - int srLastUse; - - int cacheHits; + /* yaffs2 runtime stuff */ + unsigned seq_number; /* Sequence number of currently + allocating block */ + unsigned oldest_dirty_seq; + unsigned oldest_dirty_block; + + /* Block refreshing */ + int refresh_skip; /* A skip down counter. + * Refresh happens when this gets to zero. */ + + /* Dirty directory handling */ + struct list_head dirty_dirs; /* List of dirty directories */ + + /* Summary */ + int chunks_per_summary; + struct yaffs_summary_tags *sum_tags; + + /* Statistics */ + u32 n_page_writes; + u32 n_page_reads; + u32 n_erasures; + u32 n_erase_failures; + u32 n_gc_copies; + u32 all_gcs; + u32 passive_gc_count; + u32 oldest_dirty_gc_count; + u32 n_gc_blocks; + u32 bg_gcs; + u32 n_retried_writes; + u32 n_retired_blocks; + u32 n_ecc_fixed; + u32 n_ecc_unfixed; + u32 n_tags_ecc_fixed; + u32 n_tags_ecc_unfixed; + u32 n_deletions; + u32 n_unmarked_deletions; + u32 refresh_count; + u32 cache_hits; + u32 tags_used; + u32 summary_used; - /* Stuff for background deletion and unlinked files.*/ - yaffs_Object *unlinkedDir; /* Directory where unlinked and deleted files live. */ - yaffs_Object *deletedDir; /* Directory where deleted objects are sent to disappear. */ - yaffs_Object *unlinkedDeletion; /* Current file being background deleted.*/ - int nDeletedFiles; /* Count of files awaiting deletion;*/ - int nUnlinkedFiles; /* Count of unlinked files. */ - int nBackgroundDeletions; /* Count of background deletions. */ +}; +/* The CheckpointDevice structure holds the device information that changes + *at runtime and must be preserved over unmount/mount cycles. + */ +struct yaffs_checkpt_dev { + int struct_type; + int n_erased_blocks; + int alloc_block; /* Current block being allocated off */ + u32 alloc_page; + int n_free_chunks; - yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS]; - int maxTemp; - int unmanagedTempAllocations; - int unmanagedTempDeallocations; + int n_deleted_files; /* Count of files awaiting deletion; */ + int n_unlinked_files; /* Count of unlinked files. */ + int n_bg_deletions; /* Count of background deletions. */ /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ - unsigned oldestDirtySequence; + unsigned seq_number; /* Sequence number of currently + * allocating block */ }; -typedef struct yaffs_DeviceStruct yaffs_Device; - -/* The static layout of bllock usage etc is stored in the super block header */ -typedef struct { - int StructType; - int version; - int checkpointStartBlock; - int checkpointEndBlock; - int startBlock; - int endBlock; - int rfu[100]; -} yaffs_SuperBlockHeader; - -/* The CheckpointDevice structure holds the device information that changes at runtime and - * must be preserved over unmount/mount cycles. - */ -typedef struct { - int structType; - int nErasedBlocks; - int allocationBlock; /* Current block being allocated off */ - __u32 allocationPage; - int nFreeChunks; +struct yaffs_checkpt_validity { + int struct_type; + u32 magic; + u32 version; + u32 head; +}; - int nDeletedFiles; /* Count of files awaiting deletion;*/ - int nUnlinkedFiles; /* Count of unlinked files. */ - int nBackgroundDeletions; /* Count of background deletions. */ +struct yaffs_shadow_fixer { + int obj_id; + int shadowed_id; + struct yaffs_shadow_fixer *next; +}; - /* yaffs2 runtime stuff */ - unsigned sequenceNumber; /* Sequence number of currently allocating block */ - unsigned oldestDirtySequence; - -} yaffs_CheckpointDevice; - - -typedef struct { - int structType; - __u32 magic; - __u32 version; - __u32 head; -} yaffs_CheckpointValidity; - -/* Function to manipulate block info */ -static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk) -{ - if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR), - blk)); - YBUG(); - } - return &dev->blockInfo[blk - dev->internalStartBlock]; -} +/* Structure for doing xattr modifications */ +struct yaffs_xattr_mod { + int set; /* If 0 then this is a deletion */ + const YCHAR *name; + const void *data; + int size; + int flags; + int result; +}; /*----------------------- YAFFS Functions -----------------------*/ -int yaffs_GutsInitialise(yaffs_Device * dev); -void yaffs_Deinitialise(yaffs_Device * dev); +int yaffs_guts_initialise(struct yaffs_dev *dev); +void yaffs_deinitialise(struct yaffs_dev *dev); -int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev); +int yaffs_get_n_free_chunks(struct yaffs_dev *dev); -int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName, - yaffs_Object * newDir, const YCHAR * newName); +int yaffs_rename_obj(struct yaffs_obj *old_dir, const YCHAR * old_name, + struct yaffs_obj *new_dir, const YCHAR * new_name); -int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name); -int yaffs_DeleteFile(yaffs_Object * obj); +int yaffs_unlinker(struct yaffs_obj *dir, const YCHAR * name); +int yaffs_del_obj(struct yaffs_obj *obj); -int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize); -int yaffs_GetObjectFileLength(yaffs_Object * obj); -int yaffs_GetObjectInode(yaffs_Object * obj); -unsigned yaffs_GetObjectType(yaffs_Object * obj); -int yaffs_GetObjectLinkCount(yaffs_Object * obj); - -int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr); -int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr); +int yaffs_get_obj_name(struct yaffs_obj *obj, YCHAR * name, int buffer_size); +loff_t yaffs_get_obj_length(struct yaffs_obj *obj); +int yaffs_get_obj_inode(struct yaffs_obj *obj); +unsigned yaffs_get_obj_type(struct yaffs_obj *obj); +int yaffs_get_obj_link_count(struct yaffs_obj *obj); /* File operations */ -int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset, - int nBytes); -int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset, - int nBytes, int writeThrough); -int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize); +int yaffs_file_rd(struct yaffs_obj *obj, u8 * buffer, loff_t offset, + int n_bytes); +int yaffs_wr_file(struct yaffs_obj *obj, const u8 * buffer, loff_t offset, + int n_bytes, int write_trhrough); +int yaffs_resize_file(struct yaffs_obj *obj, loff_t new_size); + +struct yaffs_obj *yaffs_create_file(struct yaffs_obj *parent, + const YCHAR *name, u32 mode, u32 uid, + u32 gid); -yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid); -int yaffs_FlushFile(yaffs_Object * obj, int updateTime); +int yaffs_flush_file(struct yaffs_obj *obj, int update_time, int data_sync); /* Flushing and checkpointing */ -void yaffs_FlushEntireDeviceCache(yaffs_Device *dev); +void yaffs_flush_whole_cache(struct yaffs_dev *dev); -int yaffs_CheckpointSave(yaffs_Device *dev); -int yaffs_CheckpointRestore(yaffs_Device *dev); +int yaffs_checkpoint_save(struct yaffs_dev *dev); +int yaffs_checkpoint_restore(struct yaffs_dev *dev); /* Directory operations */ -yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid); -yaffs_Object *yaffs_FindObjectByName(yaffs_Object * theDir, const YCHAR * name); -int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir, - int (*fn) (yaffs_Object *)); - -yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number); +struct yaffs_obj *yaffs_create_dir(struct yaffs_obj *parent, const YCHAR *name, + u32 mode, u32 uid, u32 gid); +struct yaffs_obj *yaffs_find_by_name(struct yaffs_obj *the_dir, + const YCHAR *name); +struct yaffs_obj *yaffs_find_by_number(struct yaffs_dev *dev, u32 number); /* Link operations */ -yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name, - yaffs_Object * equivalentObject); +struct yaffs_obj *yaffs_link_obj(struct yaffs_obj *parent, const YCHAR *name, + struct yaffs_obj *equiv_obj); -yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj); +struct yaffs_obj *yaffs_get_equivalent_obj(struct yaffs_obj *obj); /* Symlink operations */ -yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid, - const YCHAR * alias); -YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj); +struct yaffs_obj *yaffs_create_symlink(struct yaffs_obj *parent, + const YCHAR *name, u32 mode, u32 uid, + u32 gid, const YCHAR *alias); +YCHAR *yaffs_get_symlink_alias(struct yaffs_obj *obj); /* Special inodes (fifos, sockets and devices) */ -yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name, - __u32 mode, __u32 uid, __u32 gid, __u32 rdev); +struct yaffs_obj *yaffs_create_special(struct yaffs_obj *parent, + const YCHAR *name, u32 mode, u32 uid, + u32 gid, u32 rdev); + +int yaffs_set_xattrib(struct yaffs_obj *obj, const YCHAR *name, + const void *value, int size, int flags); +int yaffs_get_xattrib(struct yaffs_obj *obj, const YCHAR *name, void *value, + int size); +int yaffs_list_xattrib(struct yaffs_obj *obj, char *buffer, int size); +int yaffs_remove_xattrib(struct yaffs_obj *obj, const YCHAR *name); /* Special directories */ -yaffs_Object *yaffs_Root(yaffs_Device * dev); -yaffs_Object *yaffs_LostNFound(yaffs_Device * dev); +struct yaffs_obj *yaffs_root(struct yaffs_dev *dev); +struct yaffs_obj *yaffs_lost_n_found(struct yaffs_dev *dev); -#ifdef CONFIG_YAFFS_WINCE -/* CONFIG_YAFFS_WINCE special stuff */ -void yfsd_WinFileTimeNow(__u32 target[2]); -#endif +void yaffs_handle_defered_free(struct yaffs_obj *obj); -/* XXX U-BOOT XXX */ -#if 0 -#ifndef __KERNEL__ -void yaffs_HandleDeferedFree(yaffs_Object * obj); -#endif -#endif +void yaffs_update_dirty_dirs(struct yaffs_dev *dev); -/* Debug dump */ -int yaffs_DumpObject(yaffs_Object * obj); +int yaffs_bg_gc(struct yaffs_dev *dev, unsigned urgency); -void yaffs_GutsTest(yaffs_Device * dev); +/* Debug dump */ +int yaffs_dump_obj(struct yaffs_obj *obj); + +void yaffs_guts_test(struct yaffs_dev *dev); + +/* A few useful functions to be used within the core files*/ +void yaffs_chunk_del(struct yaffs_dev *dev, int chunk_id, int mark_flash, + int lyn); +int yaffs_check_ff(u8 *buffer, int n_bytes); +void yaffs_handle_chunk_error(struct yaffs_dev *dev, + struct yaffs_block_info *bi); + +u8 *yaffs_get_temp_buffer(struct yaffs_dev *dev); +void yaffs_release_temp_buffer(struct yaffs_dev *dev, u8 *buffer); + +struct yaffs_obj *yaffs_find_or_create_by_number(struct yaffs_dev *dev, + int number, + enum yaffs_obj_type type); +int yaffs_put_chunk_in_file(struct yaffs_obj *in, int inode_chunk, + int nand_chunk, int in_scan); +void yaffs_set_obj_name(struct yaffs_obj *obj, const YCHAR *name); +void yaffs_set_obj_name_from_oh(struct yaffs_obj *obj, + const struct yaffs_obj_hdr *oh); +void yaffs_add_obj_to_dir(struct yaffs_obj *directory, struct yaffs_obj *obj); +YCHAR *yaffs_clone_str(const YCHAR *str); +void yaffs_link_fixup(struct yaffs_dev *dev, struct list_head *hard_list); +void yaffs_block_became_dirty(struct yaffs_dev *dev, int block_no); +int yaffs_update_oh(struct yaffs_obj *in, const YCHAR *name, + int force, int is_shrink, int shadows, + struct yaffs_xattr_mod *xop); +void yaffs_handle_shadowed_obj(struct yaffs_dev *dev, int obj_id, + int backward_scanning); +int yaffs_check_alloc_available(struct yaffs_dev *dev, int n_chunks); +struct yaffs_tnode *yaffs_get_tnode(struct yaffs_dev *dev); +struct yaffs_tnode *yaffs_add_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id, + struct yaffs_tnode *passed_tn); + +int yaffs_do_file_wr(struct yaffs_obj *in, const u8 *buffer, loff_t offset, + int n_bytes, int write_trhrough); +void yaffs_resize_file_down(struct yaffs_obj *obj, loff_t new_size); +void yaffs_skip_rest_of_block(struct yaffs_dev *dev); + +int yaffs_count_free_chunks(struct yaffs_dev *dev); + +struct yaffs_tnode *yaffs_find_tnode_0(struct yaffs_dev *dev, + struct yaffs_file_var *file_struct, + u32 chunk_id); + +u32 yaffs_get_group_base(struct yaffs_dev *dev, struct yaffs_tnode *tn, + unsigned pos); + +int yaffs_is_non_empty_dir(struct yaffs_obj *obj); + +void yaffs_addr_to_chunk(struct yaffs_dev *dev, loff_t addr, + int *chunk_out, u32 *offset_out); +/* + * Marshalling functions to get loff_t file sizes into aand out of + * object headers. + */ +void yaffs_oh_size_load(struct yaffs_obj_hdr *oh, loff_t fsize); +loff_t yaffs_oh_to_size(struct yaffs_obj_hdr *oh); +loff_t yaffs_max_file_size(struct yaffs_dev *dev); -/* A few useful functions */ -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags); -void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn); -int yaffs_CheckFF(__u8 * buffer, int nBytes); -void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi); #endif diff --git a/fs/yaffs2/yaffs_hweight.c b/fs/yaffs2/yaffs_hweight.c new file mode 100644 index 0000000..7e2c250 --- /dev/null +++ b/fs/yaffs2/yaffs_hweight.c @@ -0,0 +1,53 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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. + */ + +/* These functions have been renamed to hweightxx to match the + * equivaqlent functions in the Linux kernel. + */ + +#include "yaffs_hweight.h" + +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_hweight8(u8 x) +{ + int ret_val; + ret_val = yaffs_count_bits_table[x]; + return ret_val; +} + +int yaffs_hweight32(u32 x) +{ + return yaffs_hweight8(x & 0xff) + + yaffs_hweight8((x >> 8) & 0xff) + + yaffs_hweight8((x >> 16) & 0xff) + + yaffs_hweight8((x >> 24) & 0xff); +} + diff --git a/fs/yaffs2/yaffs_hweight.h b/fs/yaffs2/yaffs_hweight.h new file mode 100644 index 0000000..3f7c6c3 --- /dev/null +++ b/fs/yaffs2/yaffs_hweight.h @@ -0,0 +1,24 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_HWEIGHT_H__ +#define __YAFFS_HWEIGHT_H__ + +#include "yportenv.h" + +int yaffs_hweight8(u8 x); +int yaffs_hweight32(u32 x); + +#endif diff --git a/fs/yaffs2/yaffs_list.h b/fs/yaffs2/yaffs_list.h new file mode 100644 index 0000000..a7afaea --- /dev/null +++ b/fs/yaffs2/yaffs_list.h @@ -0,0 +1,126 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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__ + + +/* + * This is a simple doubly linked list implementation that matches the + * way the Linux kernel doubly linked list implementation works. + */ + +struct list_head { + struct list_head *next; /* next in chain */ + struct list_head *prev; /* previous in chain */ +}; + + +/* Initialise a static list */ +#define LIST_HEAD(name) \ +struct list_head name = { &(name), &(name)} + + + +/* Initialise a list head to an empty list */ +#define INIT_LIST_HEAD(p) \ +do { \ + (p)->next = (p);\ + (p)->prev = (p); \ +} while (0) + + +/* Add an element to a list */ +static inline void list_add(struct list_head *new_entry, + struct list_head *list) +{ + struct list_head *list_next = list->next; + + list->next = new_entry; + new_entry->prev = list; + new_entry->next = list_next; + list_next->prev = new_entry; + +} + +static inline void list_add_tail(struct list_head *new_entry, + struct list_head *list) +{ + struct list_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 inline void list_del(struct list_head *entry) +{ + struct list_head *list_next = entry->next; + struct list_head *list_prev = entry->prev; + + list_next->prev = list_prev; + list_prev->next = list_next; + +} + +static inline void list_del_init(struct list_head *entry) +{ + list_del(entry); + entry->next = entry->prev = entry; +} + + +/* Test if the list is empty */ +static inline int list_empty(struct list_head *entry) +{ + return (entry->next == entry); +} + + +/* list_entry takes a pointer to a list entry and offsets it to that + * we can find a pointer to the object it is embedded in. + */ + + +#define list_entry(entry, type, member) \ + ((type *)((char *)(entry)-(unsigned long)(&((type *)NULL)->member))) + + +/* list_for_each and list_for_each_safe iterate over lists. + * list_for_each_safe uses temporary storage to make the list delete safe + */ + +#define list_for_each(itervar, list) \ + for (itervar = (list)->next; itervar != (list); itervar = itervar->next) + +#define list_for_each_safe(itervar, save_var, list) \ + for (itervar = (list)->next, save_var = (list)->next->next; \ + itervar != (list); \ + itervar = save_var, save_var = save_var->next) + + +#endif diff --git a/fs/yaffs2/yaffs_malloc.h b/fs/yaffs2/yaffs_malloc.h deleted file mode 100644 index 3ed6175..0000000 --- a/fs/yaffs2/yaffs_malloc.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef __YAFFS_MALLOC_H__ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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. - */ - -/* XXX U-BOOT XXX */ -#if 0 -#include <stdlib.h> -#endif - -void *yaffs_malloc(size_t size); -void yaffs_free(void *ptr); - -#endif diff --git a/fs/yaffs2/yaffs_mtdif.c b/fs/yaffs2/yaffs_mtdif.c index d0e16d0..db49052 100644 --- a/fs/yaffs2/yaffs_mtdif.c +++ b/fs/yaffs2/yaffs_mtdif.c @@ -14,9 +14,6 @@ /* XXX U-BOOT XXX */ #include <common.h> -const char *yaffs_mtdif_c_version = - "$Id: yaffs_mtdif.c,v 1.19 2007/02/14 01:09:06 wookey Exp $"; - #include "yportenv.h" @@ -27,72 +24,56 @@ const char *yaffs_mtdif_c_version = #include "linux/time.h" #include "linux/mtd/nand.h" -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) -static struct nand_oobinfo yaffs_oobinfo = { - .useecc = 1, - .eccbytes = 6, - .eccpos = {8, 9, 10, 13, 14, 15} -}; - -static struct nand_oobinfo yaffs_noeccinfo = { - .useecc = 0, -}; -#endif -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) -static inline void translate_spare2oob(const yaffs_Spare *spare, __u8 *oob) +static inline void translate_spare2oob(const struct yaffs_spare *spare, u8 *oob) { - oob[0] = spare->tagByte0; - oob[1] = spare->tagByte1; - oob[2] = spare->tagByte2; - oob[3] = spare->tagByte3; - oob[4] = spare->tagByte4; - oob[5] = spare->tagByte5 & 0x3f; - oob[5] |= spare->blockStatus == 'Y' ? 0: 0x80; - oob[5] |= spare->pageStatus == 0 ? 0: 0x40; - oob[6] = spare->tagByte6; - oob[7] = spare->tagByte7; + oob[0] = spare->tb0; + oob[1] = spare->tb1; + oob[2] = spare->tb2; + oob[3] = spare->tb3; + oob[4] = spare->tb4; + oob[5] = spare->tb5 & 0x3f; + oob[5] |= spare->block_status == 'Y' ? 0 : 0x80; + oob[5] |= spare->page_status == 0 ? 0 : 0x40; + oob[6] = spare->tb6; + oob[7] = spare->tb7; } -static inline void translate_oob2spare(yaffs_Spare *spare, __u8 *oob) +static inline void translate_oob2spare(struct yaffs_spare *spare, u8 *oob) { - struct yaffs_NANDSpare *nspare = (struct yaffs_NANDSpare *)spare; - spare->tagByte0 = oob[0]; - spare->tagByte1 = oob[1]; - spare->tagByte2 = oob[2]; - spare->tagByte3 = oob[3]; - spare->tagByte4 = oob[4]; - spare->tagByte5 = oob[5] == 0xff ? 0xff : oob[5] & 0x3f; - spare->blockStatus = oob[5] & 0x80 ? 0xff : 'Y'; - spare->pageStatus = oob[5] & 0x40 ? 0xff : 0; + struct yaffs_nand_spare *nspare = (struct yaffs_nand_spare *)spare; + spare->tb0 = oob[0]; + spare->tb1 = oob[1]; + spare->tb2 = oob[2]; + spare->tb3 = oob[3]; + spare->tb4 = oob[4]; + spare->tb5 = oob[5] == 0xff ? 0xff : oob[5] & 0x3f; + spare->block_status = oob[5] & 0x80 ? 0xff : 'Y'; + spare->page_status = oob[5] & 0x40 ? 0xff : 0; spare->ecc1[0] = spare->ecc1[1] = spare->ecc1[2] = 0xff; - spare->tagByte6 = oob[6]; - spare->tagByte7 = oob[7]; + spare->tb6 = oob[6]; + spare->tb7 = oob[7]; spare->ecc2[0] = spare->ecc2[1] = spare->ecc2[2] = 0xff; nspare->eccres1 = nspare->eccres2 = 0; /* FIXME */ } -#endif -int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, const yaffs_Spare * spare) + +int nandmtd_WriteChunkToNAND(struct yaffs_dev *dev, int chunkInNAND, + const u8 *data, const struct yaffs_spare *spare) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context); struct mtd_oob_ops ops; -#endif size_t dummy; int retval = 0; - - loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk; -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) - __u8 spareAsBytes[8]; /* OOB */ + loff_t addr = ((loff_t) chunkInNAND) * dev->data_bytes_per_chunk; + u8 spareAsBytes[8]; /* OOB */ if (data && !spare) - retval = mtd->write(mtd, addr, dev->nDataBytesPerChunk, + retval = mtd->write(mtd, addr, dev->data_bytes_per_chunk, &dummy, data); else if (spare) { - if (dev->useNANDECC) { + if (dev->param.use_nand_ecc) { translate_spare2oob(spare, spareAsBytes); ops.mode = MTD_OOB_AUTO; ops.ooblen = 8; /* temp hack */ @@ -100,37 +81,12 @@ int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND, ops.mode = MTD_OOB_RAW; ops.ooblen = YAFFS_BYTES_PER_SPARE; } - ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen; + ops.len = data ? dev->data_bytes_per_chunk : ops.ooblen; ops.datbuf = (u8 *)data; ops.ooboffs = 0; ops.oobbuf = spareAsBytes; retval = mtd->write_oob(mtd, addr, &ops); } -#else - __u8 *spareAsBytes = (__u8 *) spare; - - if (data && spare) { - if (dev->useNANDECC) - retval = - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, spareAsBytes, - &yaffs_oobinfo); - else - retval = - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, spareAsBytes, - &yaffs_noeccinfo); - } else { - if (data) - retval = - mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy, - data); - if (spare) - retval = - mtd->write_oob(mtd, addr, YAFFS_BYTES_PER_SPARE, - &dummy, spareAsBytes); - } -#endif if (retval == 0) return YAFFS_OK; @@ -138,69 +94,36 @@ int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data, - yaffs_Spare * spare) +int nandmtd_ReadChunkFromNAND(struct yaffs_dev *dev, int chunkInNAND, u8 *data, + struct yaffs_spare *spare) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context); struct mtd_oob_ops ops; -#endif size_t dummy; int retval = 0; - loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk; -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) - __u8 spareAsBytes[8]; /* OOB */ + loff_t addr = ((loff_t) chunkInNAND) * dev->data_bytes_per_chunk; + u8 spareAsBytes[8]; /* OOB */ if (data && !spare) - retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk, + retval = mtd->read(mtd, addr, dev->data_bytes_per_chunk, &dummy, data); else if (spare) { - if (dev->useNANDECC) { + if (dev->param.use_nand_ecc) { ops.mode = MTD_OOB_AUTO; ops.ooblen = 8; /* temp hack */ } else { ops.mode = MTD_OOB_RAW; ops.ooblen = YAFFS_BYTES_PER_SPARE; } - ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen; + ops.len = data ? dev->data_bytes_per_chunk : ops.ooblen; ops.datbuf = data; ops.ooboffs = 0; ops.oobbuf = spareAsBytes; retval = mtd->read_oob(mtd, addr, &ops); - if (dev->useNANDECC) + if (dev->param.use_nand_ecc) translate_oob2spare(spare, spareAsBytes); } -#else - __u8 *spareAsBytes = (__u8 *) spare; - - if (data && spare) { - if (dev->useNANDECC) { - /* Careful, this call adds 2 ints */ - /* to the end of the spare data. Calling function */ - /* should allocate enough memory for spare, */ - /* i.e. [YAFFS_BYTES_PER_SPARE+2*sizeof(int)]. */ - retval = - mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, spareAsBytes, - &yaffs_oobinfo); - } else { - retval = - mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, spareAsBytes, - &yaffs_noeccinfo); - } - } else { - if (data) - retval = - mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy, - data); - if (spare) - retval = - mtd->read_oob(mtd, addr, YAFFS_BYTES_PER_SPARE, - &dummy, spareAsBytes); - } -#endif if (retval == 0) return YAFFS_OK; @@ -208,18 +131,18 @@ int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data, return YAFFS_FAIL; } -int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber) +int nandmtd_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context); __u32 addr = - ((loff_t) blockNumber) * dev->nDataBytesPerChunk - * dev->nChunksPerBlock; + ((loff_t) blockNumber) * dev->data_bytes_per_chunk + * dev->param.chunks_per_block; struct erase_info ei; int retval = 0; ei.mtd = mtd; ei.addr = addr; - ei.len = dev->nDataBytesPerChunk * dev->nChunksPerBlock; + ei.len = dev->data_bytes_per_chunk * dev->param.chunks_per_block; ei.time = 1000; ei.retries = 2; ei.callback = NULL; @@ -227,10 +150,6 @@ int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber) /* Todo finish off the ei if required */ -/* XXX U-BOOT XXX */ -#if 0 - sema_init(&dev->sem, 0); -#endif retval = mtd->erase(mtd, &ei); @@ -240,7 +159,7 @@ int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber) return YAFFS_FAIL; } -int nandmtd_InitialiseNAND(yaffs_Device * dev) +int nandmtd_InitialiseNAND(struct yaffs_dev *dev) { return YAFFS_OK; } diff --git a/fs/yaffs2/yaffs_mtdif.h b/fs/yaffs2/yaffs_mtdif.h index 317600c..1a12582 100644 --- a/fs/yaffs2/yaffs_mtdif.h +++ b/fs/yaffs2/yaffs_mtdif.h @@ -18,10 +18,10 @@ #include "yaffs_guts.h" -int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, const yaffs_Spare * spare); -int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data, - yaffs_Spare * spare); -int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber); -int nandmtd_InitialiseNAND(yaffs_Device * dev); +int nandmtd_WriteChunkToNAND(struct yaffs_dev *dev, int chunkInNAND, + const u8 *data, const struct yaffs_spare *spare); +int nandmtd_ReadChunkFromNAND(struct yaffs_dev *dev, int chunkInNAND, u8 *data, + struct yaffs_spare *spare); +int nandmtd_EraseBlockInNAND(struct yaffs_dev *dev, int blockNumber); +int nandmtd_InitialiseNAND(struct yaffs_dev *dev); #endif diff --git a/fs/yaffs2/yaffs_mtdif2.c b/fs/yaffs2/yaffs_mtdif2.c index f569b99..b27fe56 100644 --- a/fs/yaffs2/yaffs_mtdif2.c +++ b/fs/yaffs2/yaffs_mtdif2.c @@ -17,11 +17,8 @@ #include <common.h> #include "asm/errno.h" -const char *yaffs_mtdif2_c_version = - "$Id: yaffs_mtdif2.c,v 1.17 2007/02/14 01:09:06 wookey Exp $"; - #include "yportenv.h" - +#include "yaffs_trace.h" #include "yaffs_mtdif2.h" @@ -29,71 +26,67 @@ const char *yaffs_mtdif2_c_version = #include "linux/types.h" #include "linux/time.h" +#include "yaffs_trace.h" #include "yaffs_packedtags2.h" +#include "string.h" -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, - const yaffs_ExtendedTags * tags) -{ - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) - struct mtd_oob_ops ops; -#else - size_t dummy; -#endif - int retval = 0; - - loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk; - - yaffs_PackedTags2 pt; +#define yaffs_dev_to_mtd(dev) ((struct mtd_info *)((dev)->driver_context)) +#define yaffs_dev_to_lc(dev) ((struct yaffs_linux_context *)((dev)->os_context)) - T(YAFFS_TRACE_MTD, - (TSTR - ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) - if (tags) - yaffs_PackTags2(&pt, tags); - else - BUG(); /* both tags and data should always be present */ +/* NB For use with inband tags.... + * We assume that the data buffer is of size total_bytes_per_chunk so + * that we can also use it to load the tags. + */ +int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + const u8 *data, + const struct yaffs_ext_tags *tags) +{ + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + struct mtd_oob_ops ops; - if (data) { - ops.mode = MTD_OOB_AUTO; - ops.ooblen = sizeof(pt); - ops.len = dev->nDataBytesPerChunk; - ops.ooboffs = 0; - ops.datbuf = (__u8 *)data; - ops.oobbuf = (void *)&pt; - retval = mtd->write_oob(mtd, addr, &ops); - } else - BUG(); /* both tags and data should always be present */ -#else - if (tags) { - yaffs_PackTags2(&pt, tags); - } + int retval = 0; - if (data && tags) { - if (dev->useNANDECC) - retval = - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, (__u8 *) & pt, NULL); - else - retval = - mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, (__u8 *) & pt, NULL); + loff_t addr; + u8 local_spare[128]; + + struct yaffs_packed_tags2 pt; + + int packed_tags_size = + dev->param.no_tags_ecc ? sizeof(pt.t) : sizeof(pt); + void *packed_tags_ptr = + dev->param.no_tags_ecc ? (void *)&pt.t : (void *)&pt; + + yaffs_trace(YAFFS_TRACE_MTD, + "nandmtd2_write_chunk_tags chunk %d data %p tags %p", + nand_chunk, data, tags); + + addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; + + /* For yaffs2 writing there must be both data and tags. + * If we're using inband tags, then the tags are stuffed into + * the end of the data buffer. + */ + if (!data || !tags) + BUG(); + else if (dev->param.inband_tags) { + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *)(data + + dev-> + data_bytes_per_chunk); + yaffs_pack_tags2_tags_only(pt2tp, tags); } else { - if (data) - retval = - mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy, - data); - if (tags) - retval = - mtd->write_oob(mtd, addr, mtd->oobsize, &dummy, - (__u8 *) & pt); - + yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); } -#endif + + ops.mode = MTD_OOB_AUTO; + ops.ooblen = (dev->param.inband_tags) ? 0 : packed_tags_size; + ops.len = dev->param.total_bytes_per_chunk; + ops.ooboffs = 0; + ops.datbuf = (u8 *) data; + ops.oobbuf = (dev->param.inband_tags) ? NULL : packed_tags_ptr; + retval = mtd->write_oob(mtd, addr, &ops); if (retval == 0) return YAFFS_OK; @@ -101,88 +94,97 @@ int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND, return YAFFS_FAIL; } -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, - __u8 * data, yaffs_ExtendedTags * tags) +int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int nand_chunk, + u8 *data, struct yaffs_ext_tags *tags) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); + u8 local_spare[128]; struct mtd_oob_ops ops; -#endif size_t dummy; int retval = 0; + int local_data = 0; + struct yaffs_packed_tags2 pt; + loff_t addr = ((loff_t) nand_chunk) * dev->param.total_bytes_per_chunk; + 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; + + yaffs_trace(YAFFS_TRACE_MTD, + "nandmtd2_read_chunk_tags chunk %d data %p tags %p", + nand_chunk, data, tags); + + if (dev->param.inband_tags) { + + if (!data) { + local_data = 1; + data = yaffs_get_temp_buffer(dev); + } - loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk; - - yaffs_PackedTags2 pt; - - T(YAFFS_TRACE_MTD, - (TSTR - ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p" - TENDSTR), chunkInNAND, data, tags)); + } -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) - if (data && !tags) - retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data); + 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 = sizeof(pt); - ops.len = data ? dev->nDataBytesPerChunk : sizeof(pt); + ops.ooblen = packed_tags_size; + ops.len = data ? dev->data_bytes_per_chunk : packed_tags_size; ops.ooboffs = 0; ops.datbuf = data; - ops.oobbuf = dev->spareBuffer; + ops.oobbuf = local_spare; retval = mtd->read_oob(mtd, addr, &ops); } -#else - if (data && tags) { - if (dev->useNANDECC) { - retval = - mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, dev->spareBuffer, - NULL); - } else { - retval = - mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk, - &dummy, data, dev->spareBuffer, - NULL); + + if (dev->param.inband_tags) { + if (tags) { + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = + (struct yaffs_packed_tags2_tags_only *) + &data[dev->data_bytes_per_chunk]; + yaffs_unpack_tags2_tags_only(tags, pt2tp); } } else { - if (data) - retval = - mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy, - data); - if (tags) - retval = - mtd->read_oob(mtd, addr, mtd->oobsize, &dummy, - dev->spareBuffer); + if (tags) { + memcpy(packed_tags_ptr, + local_spare, + packed_tags_size); + yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); + } } -#endif - - memcpy(&pt, dev->spareBuffer, sizeof(pt)); - if (tags) - yaffs_UnpackTags2(tags, &pt); - - if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR) - tags->eccResult = YAFFS_ECC_RESULT_UNFIXED; + if (local_data) + yaffs_release_temp_buffer(dev, data); + 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_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) + +int nandmtd2_MarkNANDBlockBad(struct yaffs_dev *dev, int blockNo) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context); int retval; - T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo)); + + yaffs_trace(YAFFS_TRACE_MTD, + "nandmtd2_MarkNANDBlockBad %d", blockNo); retval = mtd->block_markbad(mtd, - blockNo * dev->nChunksPerBlock * - dev->nDataBytesPerChunk); + blockNo * dev->param.chunks_per_block * + dev->data_bytes_per_chunk); if (retval == 0) return YAFFS_OK; @@ -191,42 +193,40 @@ int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo) } -int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState * state, int *sequenceNumber) +int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int blockNo, + enum yaffs_block_state *state, u32 *sequenceNumber) { - struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice); + struct mtd_info *mtd = (struct mtd_info *)(dev->driver_context); int retval; - T(YAFFS_TRACE_MTD, - (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo)); + yaffs_trace(YAFFS_TRACE_MTD, "nandmtd2_QueryNANDBlock %d", blockNo); retval = mtd->block_isbad(mtd, - blockNo * dev->nChunksPerBlock * - dev->nDataBytesPerChunk); + blockNo * dev->param.chunks_per_block * + dev->data_bytes_per_chunk); if (retval) { - T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR))); + yaffs_trace(YAFFS_TRACE_MTD, "block is bad"); *state = YAFFS_BLOCK_STATE_DEAD; *sequenceNumber = 0; } else { - yaffs_ExtendedTags t; - nandmtd2_ReadChunkWithTagsFromNAND(dev, - blockNo * - dev->nChunksPerBlock, NULL, - &t); - - if (t.chunkUsed) { - *sequenceNumber = t.sequenceNumber; - *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + struct yaffs_ext_tags t; + nandmtd2_read_chunk_tags(dev, + blockNo * + dev->param.chunks_per_block, NULL, + &t); + + if (t.chunk_used) { + *sequenceNumber = t.seq_number; + *state = YAFFS_BLOCK_STATE_NEEDS_SCAN; } else { *sequenceNumber = 0; *state = YAFFS_BLOCK_STATE_EMPTY; } } - T(YAFFS_TRACE_MTD, - (TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber, - *state)); + yaffs_trace(YAFFS_TRACE_MTD, "block is bad seq %d state %d", + *sequenceNumber, *state); if (retval == 0) return YAFFS_OK; diff --git a/fs/yaffs2/yaffs_mtdif2.h b/fs/yaffs2/yaffs_mtdif2.h index b67ba52..62be173 100644 --- a/fs/yaffs2/yaffs_mtdif2.h +++ b/fs/yaffs2/yaffs_mtdif2.h @@ -17,13 +17,14 @@ #define __YAFFS_MTDIF2_H__ #include "yaffs_guts.h" -int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, - const yaffs_ExtendedTags * tags); -int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, - __u8 * data, yaffs_ExtendedTags * tags); -int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState * state, int *sequenceNumber); + +int nandmtd2_write_chunk_tags(struct yaffs_dev *dev, int chunkInNAND, + const u8 *data, + const struct yaffs_ext_tags *tags); +int nandmtd2_read_chunk_tags(struct yaffs_dev *dev, int chunkInNAND, + u8 *data, struct yaffs_ext_tags *tags); +int nandmtd2_MarkNANDBlockBad(struct yaffs_dev *dev, int blockNo); +int nandmtd2_QueryNANDBlock(struct yaffs_dev *dev, int blockNo, + enum yaffs_block_state *state, u32 *sequenceNumber); #endif diff --git a/fs/yaffs2/yaffs_nameval.c b/fs/yaffs2/yaffs_nameval.c new file mode 100644 index 0000000..a20a3e4 --- /dev/null +++ b/fs/yaffs2/yaffs_nameval.c @@ -0,0 +1,208 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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. + * yaffs_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)) { + 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 -ENODATA; +} + +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) + return -ENODATA; + + /* 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; +} + +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 bsize is zero then this is a size query. + * Return the size, but don't copy. + */ + if (!bsize) + return size; + + if (size <= bsize) { + memcpy(buf, xb + pos, size); + return size; + } + } + if (pos >= 0) + return -ERANGE; + + 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; +} diff --git a/fs/yaffs2/yaffs_nameval.h b/fs/yaffs2/yaffs_nameval.h new file mode 100644 index 0000000..951e64f --- /dev/null +++ b/fs/yaffs2/yaffs_nameval.h @@ -0,0 +1,28 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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 diff --git a/fs/yaffs2/yaffs_nand.c b/fs/yaffs2/yaffs_nand.c index ce048cc..165d010 100644 --- a/fs/yaffs2/yaffs_nand.c +++ b/fs/yaffs2/yaffs_nand.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -11,124 +11,110 @@ * published by the Free Software Foundation. */ -/* XXX U-BOOT XXX */ -#include <common.h> - -const char *yaffs_nand_c_version = - "$Id: yaffs_nand.c,v 1.7 2007/02/14 01:09:06 wookey Exp $"; - #include "yaffs_nand.h" #include "yaffs_tagscompat.h" -#include "yaffs_tagsvalidity.h" +#include "yaffs_getblockinfo.h" +#include "yaffs_summary.h" -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, - __u8 * buffer, - yaffs_ExtendedTags * tags) +int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, + u8 *buffer, struct yaffs_ext_tags *tags) { int result; - yaffs_ExtendedTags localTags; + struct yaffs_ext_tags local_tags; + int flash_chunk = nand_chunk - dev->chunk_offset; - int realignedChunkInNAND = chunkInNAND - dev->chunkOffset; + dev->n_page_reads++; - /* If there are no tags provided, use local tags to get prioritised gc working */ - if(!tags) - tags = &localTags; + /* If there are no tags provided use local tags. */ + if (!tags) + tags = &local_tags; - if (dev->readChunkWithTagsFromNAND) - result = dev->readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer, - tags); + if (dev->param.read_chunk_tags_fn) + result = + dev->param.read_chunk_tags_fn(dev, flash_chunk, buffer, + tags); else - result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev, - realignedChunkInNAND, - buffer, - tags); - if(tags && - tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){ - - yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock); - yaffs_HandleChunkError(dev,bi); + result = yaffs_tags_compat_rd(dev, + flash_chunk, buffer, tags); + if (tags && tags->ecc_result > YAFFS_ECC_RESULT_NO_ERROR) { + + struct yaffs_block_info *bi; + bi = yaffs_get_block_info(dev, + nand_chunk / + dev->param.chunks_per_block); + yaffs_handle_chunk_error(dev, bi); } - return result; } -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev, - int chunkInNAND, - const __u8 * buffer, - yaffs_ExtendedTags * tags) +int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, + int nand_chunk, + const u8 *buffer, struct yaffs_ext_tags *tags) { - chunkInNAND -= dev->chunkOffset; + int result; + int flash_chunk = nand_chunk - dev->chunk_offset; + dev->n_page_writes++; if (tags) { - tags->sequenceNumber = dev->sequenceNumber; - tags->chunkUsed = 1; - if (!yaffs_ValidateTags(tags)) { - T(YAFFS_TRACE_ERROR, - (TSTR("Writing uninitialised tags" TENDSTR))); - YBUG(); - } - T(YAFFS_TRACE_WRITE, - (TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND, - tags->objectId, tags->chunkId)); + tags->seq_number = dev->seq_number; + tags->chunk_used = 1; + yaffs_trace(YAFFS_TRACE_WRITE, + "Writing chunk %d tags %d %d", + nand_chunk, tags->obj_id, tags->chunk_id); } else { - T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR))); - YBUG(); + yaffs_trace(YAFFS_TRACE_ERROR, "Writing with no tags"); + BUG(); + return YAFFS_FAIL; } - if (dev->writeChunkWithTagsToNAND) - return dev->writeChunkWithTagsToNAND(dev, chunkInNAND, buffer, - tags); + if (dev->param.write_chunk_tags_fn) + result = dev->param.write_chunk_tags_fn(dev, flash_chunk, + buffer, tags); else - return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev, - chunkInNAND, - buffer, - tags); + result = yaffs_tags_compat_wr(dev, flash_chunk, buffer, tags); + + yaffs_summary_add(dev, tags, nand_chunk); + + return result; } -int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo) +int yaffs_mark_bad(struct yaffs_dev *dev, int block_no) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; + if (dev->param.bad_block_fn) + return dev->param.bad_block_fn(dev, block_no); -; - if (dev->markNANDBlockBad) - return dev->markNANDBlockBad(dev, blockNo); - else - return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo); + return yaffs_tags_compat_mark_bad(dev, block_no); } -int yaffs_QueryInitialBlockState(yaffs_Device * dev, - int blockNo, - yaffs_BlockState * state, - int *sequenceNumber) +int yaffs_query_init_block_state(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 *seq_number) { - blockNo -= dev->blockOffset; + block_no -= dev->block_offset; + if (dev->param.query_block_fn) + return dev->param.query_block_fn(dev, block_no, state, + seq_number); - if (dev->queryNANDBlock) - return dev->queryNANDBlock(dev, blockNo, state, sequenceNumber); - else - return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo, - state, - sequenceNumber); + return yaffs_tags_compat_query_block(dev, block_no, state, seq_number); } - -int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block) { int result; - blockInNAND -= dev->blockOffset; - - - dev->nBlockErasures++; - result = dev->eraseBlockInNAND(dev, blockInNAND); - + flash_block -= dev->block_offset; + dev->n_erasures++; + result = dev->param.erase_fn(dev, flash_block); return result; } -int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev) +int yaffs_init_nand(struct yaffs_dev *dev) { - return dev->initialiseNAND(dev); + if (dev->param.initialise_flash_fn) + return dev->param.initialise_flash_fn(dev); + return YAFFS_OK; } diff --git a/fs/yaffs2/yaffs_nand.h b/fs/yaffs2/yaffs_nand.h index f3bedcf..7134662 100644 --- a/fs/yaffs2/yaffs_nand.h +++ b/fs/yaffs2/yaffs_nand.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -17,27 +17,22 @@ #define __YAFFS_NAND_H__ #include "yaffs_guts.h" +int yaffs_rd_chunk_tags_nand(struct yaffs_dev *dev, int nand_chunk, + u8 *buffer, struct yaffs_ext_tags *tags); +int yaffs_wr_chunk_tags_nand(struct yaffs_dev *dev, + int nand_chunk, + const u8 *buffer, struct yaffs_ext_tags *tags); -int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND, - __u8 * buffer, - yaffs_ExtendedTags * tags); +int yaffs_mark_bad(struct yaffs_dev *dev, int block_no); -int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev, - int chunkInNAND, - const __u8 * buffer, - yaffs_ExtendedTags * tags); +int yaffs_query_init_block_state(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + unsigned *seq_number); -int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo); +int yaffs_erase_block(struct yaffs_dev *dev, int flash_block); -int yaffs_QueryInitialBlockState(yaffs_Device * dev, - int blockNo, - yaffs_BlockState * state, - int *sequenceNumber); - -int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND); - -int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev); +int yaffs_init_nand(struct yaffs_dev *dev); #endif diff --git a/fs/yaffs2/yaffs_nandemul2k.h b/fs/yaffs2/yaffs_nandemul2k.h index cd2e96f..cb0c4e6 100644 --- a/fs/yaffs2/yaffs_nandemul2k.h +++ b/fs/yaffs2/yaffs_nandemul2k.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -20,18 +20,18 @@ #include "yaffs_guts.h" -int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 * data, - yaffs_ExtendedTags * tags); -int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, __u8 * data, - yaffs_ExtendedTags * tags); -int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo); -int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo, - yaffs_BlockState * state, int *sequenceNumber); -int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev, - int blockInNAND); -int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev); +int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, + int nand_chunk, const u8 *data, + const struct yaffs_ext_tags *tags); +int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, + int nand_chunk, u8 *data, + struct yaffs_ext_tags *tags); +int nandemul2k_MarkNANDBlockBad(struct yaffs_dev *dev, int block_no); +int nandemul2k_QueryNANDBlock(struct yaffs_dev *dev, int block_no, + enum yaffs_block_state *state, u32 *seq_number); +int nandemul2k_EraseBlockInNAND(struct yaffs_dev *dev, + int flash_block); +int nandemul2k_InitialiseNAND(struct yaffs_dev *dev); int nandemul2k_GetBytesPerChunk(void); int nandemul2k_GetChunksPerBlock(void); int nandemul2k_GetNumberOfBlocks(void); diff --git a/fs/yaffs2/yaffs_nandif.c b/fs/yaffs2/yaffs_nandif.c new file mode 100644 index 0000000..3f1de6d --- /dev/null +++ b/fs/yaffs2/yaffs_nandif.c @@ -0,0 +1,252 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_guts.h" + + +#include "yaffs_nandif.h" +#include "yaffs_packedtags2.h" + +#include "yramsim.h" + +#include "yaffs_trace.h" +#include "yaffsfs.h" + + +/* NB For use with inband tags.... + * We assume that the data buffer is of size totalBytersPerChunk so that + * we can also use it to load the tags. + */ +int ynandif_WriteChunkWithTagsToNAND(struct yaffs_dev *dev, int nand_chunk, + const u8 *data, + const struct yaffs_ext_tags *tags) +{ + + int retval = 0; + struct yaffs_packed_tags2 pt; + void *spare; + unsigned spareSize = 0; + struct ynandif_Geometry *geometry = (struct ynandif_Geometry *)(dev->driver_context); + + yaffs_trace(YAFFS_TRACE_MTD, + "nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p", + nand_chunk, data, tags); + + + /* 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 (dev->param.inband_tags) { + struct yaffs_packed_tags2_tags_only *pt2tp; + + pt2tp = (struct yaffs_packed_tags2_tags_only *) + (data + dev->data_bytes_per_chunk); + yaffs_pack_tags2_tags_only(pt2tp, tags); + spare = NULL; + spareSize = 0; + } else { + yaffs_pack_tags2(&pt, tags, !dev->param.no_tags_ecc); + spare = &pt; + spareSize = sizeof(struct yaffs_packed_tags2); + } + + retval = geometry->writeChunk(dev, nand_chunk, + data, dev->param.total_bytes_per_chunk, + spare, spareSize); + + return retval; +} + +int ynandif_ReadChunkWithTagsFromNAND(struct yaffs_dev *dev, int nand_chunk, + u8 *data, struct yaffs_ext_tags *tags) +{ + struct yaffs_packed_tags2 pt; + int localData = 0; + void *spare = NULL; + unsigned spareSize; + int retval = 0; + int eccStatus; /* 0 = ok, 1 = fixed, -1 = unfixed */ + struct ynandif_Geometry *geometry = (struct ynandif_Geometry *)(dev->driver_context); + + yaffs_trace(YAFFS_TRACE_MTD, + "nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p", + nand_chunk, data, tags); + + if (!tags) { + spare = NULL; + spareSize = 0; + } else if (dev->param.inband_tags) { + + if (!data) { + localData = 1; + data = yaffs_get_temp_buffer(dev); + } + spare = NULL; + spareSize = 0; + } else { + spare = &pt; + spareSize = sizeof(struct yaffs_packed_tags2); + } + + retval = geometry->readChunk(dev, nand_chunk, + data, + data ? dev->param.total_bytes_per_chunk : 0, + spare, spareSize, + &eccStatus); + + if (dev->param.inband_tags) { + if (tags) { + struct yaffs_packed_tags2_tags_only *pt2tp; + pt2tp = (struct yaffs_packed_tags2_tags_only *) + &data[dev->data_bytes_per_chunk]; + yaffs_unpack_tags2_tags_only(tags, pt2tp); + } + } else { + if (tags) + yaffs_unpack_tags2(tags, &pt, !dev->param.no_tags_ecc); + } + + if (tags && tags->chunk_used) { + if (eccStatus < 0 || + tags->ecc_result == YAFFS_ECC_RESULT_UNFIXED) + tags->ecc_result = YAFFS_ECC_RESULT_UNFIXED; + else if (eccStatus > 0 || + tags->ecc_result == YAFFS_ECC_RESULT_FIXED) + tags->ecc_result = YAFFS_ECC_RESULT_FIXED; + else + tags->ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + } + + if (localData) + yaffs_release_temp_buffer(dev, data); + + return retval; +} + +int ynandif_MarkNANDBlockBad(struct yaffs_dev *dev, int blockId) +{ + struct ynandif_Geometry *geometry = (struct ynandif_Geometry *)(dev->driver_context); + + return geometry->markBlockBad(dev, blockId); +} + +int ynandif_EraseBlockInNAND(struct yaffs_dev *dev, int blockId) +{ + struct ynandif_Geometry *geometry = (struct ynandif_Geometry *)(dev->driver_context); + + return geometry->eraseBlock(dev, blockId); + +} + + +static int ynandif_IsBlockOk(struct yaffs_dev *dev, int blockId) +{ + struct ynandif_Geometry *geometry = (struct ynandif_Geometry *)(dev->driver_context); + + return geometry->checkBlockOk(dev, blockId); +} + +int ynandif_QueryNANDBlock(struct yaffs_dev *dev, int blockId, + enum yaffs_block_state *state, u32 *seq_number) +{ + unsigned chunkNo; + struct yaffs_ext_tags tags; + + *seq_number = 0; + + chunkNo = blockId * dev->param.chunks_per_block; + + if (!ynandif_IsBlockOk(dev, blockId)) { + *state = YAFFS_BLOCK_STATE_DEAD; + } else { + ynandif_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &tags); + + if (!tags.chunk_used) { + *state = YAFFS_BLOCK_STATE_EMPTY; + } else { + *state = YAFFS_BLOCK_STATE_NEEDS_SCAN; + *seq_number = tags.seq_number; + } + } + + return YAFFS_OK; +} + + +int ynandif_InitialiseNAND(struct yaffs_dev *dev) +{ + struct ynandif_Geometry *geometry = (struct ynandif_Geometry *)(dev->driver_context); + + geometry->initialise(dev); + + return YAFFS_OK; +} + +int ynandif_Deinitialise_flash_fn(struct yaffs_dev *dev) +{ + struct ynandif_Geometry *geometry = (struct ynandif_Geometry *)(dev->driver_context); + + geometry->deinitialise(dev); + + return YAFFS_OK; +} + + +struct yaffs_dev * + yaffs_add_dev_from_geometry(const YCHAR *name, + const struct ynandif_Geometry *geometry) +{ + YCHAR *clonedName = malloc(sizeof(YCHAR) * + (strnlen(name, YAFFS_MAX_NAME_LENGTH)+1)); + struct yaffs_dev *dev = malloc(sizeof(struct yaffs_dev)); + struct yaffs_param *param; + + if (dev && clonedName) { + memset(dev, 0, sizeof(struct yaffs_dev)); + strcpy(clonedName, name); + + param = &dev->param; + + param->name = clonedName; + param->write_chunk_tags_fn = ynandif_WriteChunkWithTagsToNAND; + param->read_chunk_tags_fn = ynandif_ReadChunkWithTagsFromNAND; + param->erase_fn = ynandif_EraseBlockInNAND; + param->initialise_flash_fn = ynandif_InitialiseNAND; + param->query_block_fn = ynandif_QueryNANDBlock; + param->bad_block_fn = ynandif_MarkNANDBlockBad; + param->n_caches = 20; + param->start_block = geometry->start_block; + param->end_block = geometry->end_block; + param->total_bytes_per_chunk = geometry->dataSize; + param->spare_bytes_per_chunk = geometry->spareSize; + param->inband_tags = geometry->inband_tags; + param->chunks_per_block = geometry->pagesPerBlock; + param->use_nand_ecc = geometry->hasECC; + param->is_yaffs2 = geometry->useYaffs2; + param->n_reserved_blocks = 5; + dev->driver_context = (void *)geometry; + + yaffs_add_device(dev); + + return dev; + } + + free(dev); + free(clonedName); + + return NULL; +} + diff --git a/fs/yaffs2/yaffs_nandif.h b/fs/yaffs2/yaffs_nandif.h new file mode 100644 index 0000000..e780f7f --- /dev/null +++ b/fs/yaffs2/yaffs_nandif.h @@ -0,0 +1,65 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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 __YNANDIF_H__ +#define __YNANDIF_H__ + +#include "yaffs_guts.h" + +struct ynandif_Geometry { + unsigned start_block; + unsigned end_block; + unsigned dataSize; + unsigned spareSize; + unsigned pagesPerBlock; + unsigned hasECC; + unsigned inband_tags; + unsigned useYaffs2; + + int (*initialise)(struct yaffs_dev *dev); + int (*deinitialise)(struct yaffs_dev *dev); + + int (*readChunk) (struct yaffs_dev *dev, + unsigned pageId, + unsigned char *data, + unsigned dataLength, + unsigned char *spare, + unsigned spareLength, + int *eccStatus); + /* ECC status is set to 0 for OK, 1 for fixed, -1 for unfixed. */ + + int (*writeChunk)(struct yaffs_dev *dev, + unsigned pageId, + const unsigned char *data, + unsigned dataLength, + const unsigned char *spare, + unsigned spareLength); + + int (*eraseBlock)(struct yaffs_dev *dev, unsigned blockId); + + int (*checkBlockOk)(struct yaffs_dev *dev, unsigned blockId); + int (*markBlockBad)(struct yaffs_dev *dev, unsigned blockId); + + void *privateData; + +}; + +struct yaffs_dev * + yaffs_add_dev_from_geometry(const YCHAR *name, + const struct ynandif_Geometry *geometry); + + +#endif diff --git a/fs/yaffs2/yaffs_osglue.h b/fs/yaffs2/yaffs_osglue.h new file mode 100644 index 0000000..bb008f9 --- /dev/null +++ b/fs/yaffs2/yaffs_osglue.h @@ -0,0 +1,42 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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. + */ + +/* + * Header file for using yaffs in an application via + * a direct interface. + */ + + +#ifndef __YAFFS_OSGLUE_H__ +#define __YAFFS_OSGLUE_H__ + + +#include "yportenv.h" + +void yaffsfs_Lock(void); +void yaffsfs_Unlock(void); + +u32 yaffsfs_CurrentTime(void); + +void yaffsfs_SetError(int err); + +void *yaffsfs_malloc(size_t size); +void yaffsfs_free(void *ptr); + +void yaffsfs_OSInitialisation(void); + + +#endif + diff --git a/fs/yaffs2/yaffs_packedtags1.c b/fs/yaffs2/yaffs_packedtags1.c index a149431..dd9a331 100644 --- a/fs/yaffs2/yaffs_packedtags1.c +++ b/fs/yaffs2/yaffs_packedtags1.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -11,45 +11,46 @@ * published by the Free Software Foundation. */ -/* XXX U-BOOT XXX */ -#include <common.h> - #include "yaffs_packedtags1.h" #include "yportenv.h" -void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t) +static const u8 all_ff[20] = { + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff +}; + +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t) { - pt->chunkId = t->chunkId; - pt->serialNumber = t->serialNumber; - pt->byteCount = t->byteCount; - pt->objectId = t->objectId; + 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->chunkDeleted) ? 0 : 1; - pt->unusedStuff = 0; - pt->shouldBeFF = 0xFFFFFFFF; - + pt->deleted = (t->is_deleted) ? 0 : 1; + pt->unused_stuff = 0; + pt->should_be_ff = 0xffffffff; } -void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt) +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt) { - static const __u8 allFF[] = - { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, -0xff }; - if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) { - t->blockBad = 0; - if (pt->shouldBeFF != 0xFFFFFFFF) { - t->blockBad = 1; - } - t->chunkUsed = 1; - t->objectId = pt->objectId; - t->chunkId = pt->chunkId; - t->byteCount = pt->byteCount; - t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; - t->chunkDeleted = (pt->deleted) ? 0 : 1; - t->serialNumber = pt->serialNumber; + if (memcmp(all_ff, pt, sizeof(struct 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_ExtendedTags)); - + memset(t, 0, sizeof(struct yaffs_ext_tags)); } } diff --git a/fs/yaffs2/yaffs_packedtags1.h b/fs/yaffs2/yaffs_packedtags1.h index 776c5c2..b80f0a5 100644 --- a/fs/yaffs2/yaffs_packedtags1.h +++ b/fs/yaffs2/yaffs_packedtags1.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -20,18 +20,20 @@ #include "yaffs_guts.h" -typedef struct { - unsigned chunkId:20; - unsigned serialNumber:2; - unsigned byteCount:10; - unsigned objectId:18; +struct yaffs_packed_tags1 { + unsigned chunk_id:20; + unsigned serial_number:2; + unsigned n_bytes:10; + unsigned obj_id:18; unsigned ecc:12; unsigned deleted:1; - unsigned unusedStuff:1; - unsigned shouldBeFF; + unsigned unused_stuff:1; + unsigned should_be_ff; -} yaffs_PackedTags1; +}; -void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t); -void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt); +void yaffs_pack_tags1(struct yaffs_packed_tags1 *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags1(struct yaffs_ext_tags *t, + const struct yaffs_packed_tags1 *pt); #endif diff --git a/fs/yaffs2/yaffs_packedtags2.c b/fs/yaffs2/yaffs_packedtags2.c index 4744009..e1d18cc 100644 --- a/fs/yaffs2/yaffs_packedtags2.c +++ b/fs/yaffs2/yaffs_packedtags2.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -11,12 +11,9 @@ * published by the Free Software Foundation. */ -/* XXX U-BOOT XXX */ -#include <common.h> - #include "yaffs_packedtags2.h" #include "yportenv.h" -#include "yaffs_tagsvalidity.h" +#include "yaffs_trace.h" /* This code packs a set of extended tags into a binary structure for * NAND storage @@ -27,159 +24,174 @@ * This is defined by having the EXTRA_HEADER_INFO_FLAG set. */ -/* Extra flags applied to chunkId */ +/* 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 +#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) +#define EXTRA_OBJECT_TYPE_MASK ((0x0f) << EXTRA_OBJECT_TYPE_SHIFT) -static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt) +static void yaffs_dump_packed_tags2_tags_only( + const struct yaffs_packed_tags2_tags_only *ptt) { - T(YAFFS_TRACE_MTD, - (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR), - pt->t.objectId, pt->t.chunkId, pt->t.byteCount, - pt->t.sequenceNumber)); + yaffs_trace(YAFFS_TRACE_MTD, + "packed tags obj %d chunk %d byte %d seq %d", + ptt->obj_id, ptt->chunk_id, ptt->n_bytes, ptt->seq_number); } -static void yaffs_DumpTags2(const yaffs_ExtendedTags * t) +static void yaffs_dump_packed_tags2(const struct yaffs_packed_tags2 *pt) { - 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->eccResult, t->blockBad, t->chunkUsed, t->objectId, - t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber, - t->sequenceNumber)); - + yaffs_dump_packed_tags2_tags_only(&pt->t); } -void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t) +static void yaffs_dump_tags2(const struct yaffs_ext_tags *t) { - pt->t.chunkId = t->chunkId; - pt->t.sequenceNumber = t->sequenceNumber; - pt->t.byteCount = t->byteCount; - pt->t.objectId = t->objectId; + yaffs_trace(YAFFS_TRACE_MTD, + "ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte %d del %d ser %d seq %d", + 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); - if (t->chunkId == 0 && t->extraHeaderInfoAvailable) { - /* Store the extra header info instead */ - /* We save the parent object in the chunkId */ - pt->t.chunkId = EXTRA_HEADER_INFO_FLAG - | t->extraParentObjectId; - if (t->extraIsShrinkHeader) { - pt->t.chunkId |= EXTRA_SHRINK_FLAG; - } - if (t->extraShadows) { - pt->t.chunkId |= EXTRA_SHADOWS_FLAG; - } +} - pt->t.objectId &= ~EXTRA_OBJECT_TYPE_MASK; - pt->t.objectId |= - (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT); +static int yaffs_check_tags_extra_packable(const struct yaffs_ext_tags *t) +{ + if (t->chunk_id != 0 || !t->extra_available) + return 0; + + /* Check if the file size is too long to store */ + if (t->extra_obj_type == YAFFS_OBJECT_TYPE_FILE && + (t->extra_file_size >> 31) != 0) + return 0; + return 1; +} - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) { - pt->t.byteCount = t->extraEquivalentObjectId; - } else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) { - pt->t.byteCount = t->extraFileLength; - } else { - pt->t.byteCount = 0; - } +void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *ptt, + const struct yaffs_ext_tags *t) +{ + ptt->chunk_id = t->chunk_id; + ptt->seq_number = t->seq_number; + ptt->n_bytes = t->n_bytes; + ptt->obj_id = t->obj_id; + + /* Only store extra tags for object headers. + * If it is a file then only store if the file size is short\ + * enough to fit. + */ + if (yaffs_check_tags_extra_packable(t)) { + /* 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 = (unsigned) t->extra_file_size; + else + ptt->n_bytes = 0; } - yaffs_DumpPackedTags2(pt); - yaffs_DumpTags2(t); - -#ifndef YAFFS_IGNORE_TAGS_ECC - { - yaffs_ECCCalculateOther((unsigned char *)&pt->t, - sizeof(yaffs_PackedTags2TagsPart), - &pt->ecc); - } -#endif + yaffs_dump_packed_tags2_tags_only(ptt); + yaffs_dump_tags2(t); } -void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt) +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc) { + yaffs_pack_tags2_tags_only(&pt->t, t); - memset(t, 0, sizeof(yaffs_ExtendedTags)); + if (tags_ecc) + yaffs_ecc_calc_other((unsigned char *)&pt->t, + sizeof(struct yaffs_packed_tags2_tags_only), + &pt->ecc); +} - yaffs_InitialiseTags(t); +void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, + struct yaffs_packed_tags2_tags_only *ptt) +{ + memset(t, 0, sizeof(struct yaffs_ext_tags)); + + if (ptt->seq_number == 0xffffffff) + return; + + 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_file_size = ptt->n_bytes; + } + yaffs_dump_packed_tags2_tags_only(ptt); + yaffs_dump_tags2(t); +} - if (pt->t.sequenceNumber != 0xFFFFFFFF) { - /* Page is in use */ -#ifdef YAFFS_IGNORE_TAGS_ECC - { - t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; - } -#else - { - yaffs_ECCOther ecc; - int result; - yaffs_ECCCalculateOther((unsigned char *)&pt->t, - sizeof - (yaffs_PackedTags2TagsPart), - &ecc); - result = - yaffs_ECCCorrectOther((unsigned char *)&pt->t, - sizeof - (yaffs_PackedTags2TagsPart), - &pt->ecc, &ecc); - switch(result){ - case 0: - t->eccResult = YAFFS_ECC_RESULT_NO_ERROR; - break; - case 1: - t->eccResult = YAFFS_ECC_RESULT_FIXED; - break; - case -1: - t->eccResult = YAFFS_ECC_RESULT_UNFIXED; - break; - default: - t->eccResult = YAFFS_ECC_RESULT_UNKNOWN; - } - } -#endif - t->blockBad = 0; - t->chunkUsed = 1; - t->objectId = pt->t.objectId; - t->chunkId = pt->t.chunkId; - t->byteCount = pt->t.byteCount; - t->chunkDeleted = 0; - t->serialNumber = 0; - t->sequenceNumber = pt->t.sequenceNumber; - - /* Do extra header info stuff */ - - if (pt->t.chunkId & EXTRA_HEADER_INFO_FLAG) { - t->chunkId = 0; - t->byteCount = 0; - - t->extraHeaderInfoAvailable = 1; - t->extraParentObjectId = - pt->t.chunkId & (~(ALL_EXTRA_FLAGS)); - t->extraIsShrinkHeader = - (pt->t.chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0; - t->extraShadows = - (pt->t.chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0; - t->extraObjectType = - pt->t.objectId >> EXTRA_OBJECT_TYPE_SHIFT; - t->objectId &= ~EXTRA_OBJECT_TYPE_MASK; - - if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) { - t->extraEquivalentObjectId = pt->t.byteCount; - } else { - t->extraFileLength = pt->t.byteCount; - } +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc) +{ + enum 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 */ + + struct yaffs_ecc_other ecc; + int result; + yaffs_ecc_calc_other((unsigned char *)&pt->t, + sizeof(struct yaffs_packed_tags2_tags_only), + &ecc); + result = + yaffs_ecc_correct_other((unsigned char *)&pt->t, + sizeof(struct yaffs_packed_tags2_tags_only), + &pt->ecc, &ecc); + switch (result) { + case 0: + ecc_result = YAFFS_ECC_RESULT_NO_ERROR; + break; + case 1: + ecc_result = YAFFS_ECC_RESULT_FIXED; + break; + case -1: + ecc_result = YAFFS_ECC_RESULT_UNFIXED; + break; + default: + ecc_result = YAFFS_ECC_RESULT_UNKNOWN; } } + yaffs_unpack_tags2_tags_only(t, &pt->t); - yaffs_DumpPackedTags2(pt); - yaffs_DumpTags2(t); + t->ecc_result = ecc_result; + yaffs_dump_packed_tags2(pt); + yaffs_dump_tags2(t); } diff --git a/fs/yaffs2/yaffs_packedtags2.h b/fs/yaffs2/yaffs_packedtags2.h index c2242ff..675e719 100644 --- a/fs/yaffs2/yaffs_packedtags2.h +++ b/fs/yaffs2/yaffs_packedtags2.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -21,18 +21,27 @@ #include "yaffs_guts.h" #include "yaffs_ecc.h" -typedef struct { - unsigned sequenceNumber; - unsigned objectId; - unsigned chunkId; - unsigned byteCount; -} yaffs_PackedTags2TagsPart; +struct yaffs_packed_tags2_tags_only { + unsigned seq_number; + unsigned obj_id; + unsigned chunk_id; + unsigned n_bytes; +}; -typedef struct { - yaffs_PackedTags2TagsPart t; - yaffs_ECCOther ecc; -} yaffs_PackedTags2; +struct yaffs_packed_tags2 { + struct yaffs_packed_tags2_tags_only t; + struct yaffs_ecc_other ecc; +}; -void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t); -void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt); +/* Full packed tags with ECC, used for oob tags */ +void yaffs_pack_tags2(struct yaffs_packed_tags2 *pt, + const struct yaffs_ext_tags *t, int tags_ecc); +void yaffs_unpack_tags2(struct yaffs_ext_tags *t, struct yaffs_packed_tags2 *pt, + int tags_ecc); + +/* Only the tags part (no ECC for use with inband tags */ +void yaffs_pack_tags2_tags_only(struct yaffs_packed_tags2_tags_only *pt, + const struct yaffs_ext_tags *t); +void yaffs_unpack_tags2_tags_only(struct yaffs_ext_tags *t, + struct yaffs_packed_tags2_tags_only *pt); #endif diff --git a/fs/yaffs2/yaffs_qsort.c b/fs/yaffs2/yaffs_qsort.c index 4d56f96..afd1ffa 100644 --- a/fs/yaffs2/yaffs_qsort.c +++ b/fs/yaffs2/yaffs_qsort.c @@ -27,58 +27,56 @@ * SUCH DAMAGE. */ -/* XXX U-BOOT XXX */ -#include <common.h> - #include "yportenv.h" -//#include <linux/string.h> +/* #include <linux/string.h> */ /* * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function". */ -#define swapcode(TYPE, parmi, parmj, n) { \ - long i = (n) / sizeof (TYPE); \ - register TYPE *pi = (TYPE *) (parmi); \ - register TYPE *pj = (TYPE *) (parmj); \ - do { \ +#define swapcode(TYPE, parmi, parmj, n) do { \ + long i = (n) / sizeof(TYPE); \ + register TYPE *pi = (TYPE *) (parmi); \ + register TYPE *pj = (TYPE *) (parmj); \ + do { \ register TYPE t = *pi; \ *pi++ = *pj; \ *pj++ = t; \ } while (--i > 0); \ -} +} while (0) #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \ - es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1; + es % sizeof(long) ? 2 : es == sizeof(long) ? 0 : 1; -static __inline void +static inline void swapfunc(char *a, char *b, int n, int swaptype) { if (swaptype <= 1) - swapcode(long, a, b, n) + swapcode(long, a, b, n); else - swapcode(char, a, b, n) + swapcode(char, a, b, n); } -#define swap(a, b) \ +#define yswap(a, b) do { \ if (swaptype == 0) { \ long t = *(long *)(a); \ *(long *)(a) = *(long *)(b); \ *(long *)(b) = t; \ } else \ - swapfunc(a, b, es, swaptype) + swapfunc(a, b, es, swaptype); \ +} while (0) -#define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype) +#define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype) -static __inline char * +static inline char * med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *)) { return cmp(a, b) < 0 ? - (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a )) - :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c )); + (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a)) + : (cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c)); } #ifndef min -#define min(a,b) (((a) < (b)) ? (a) : (b)) +#define min(a, b) (((a) < (b)) ? (a) : (b)) #endif void @@ -95,7 +93,7 @@ loop: SWAPINIT(a, es); for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es) for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; pl -= es) - swap(pl, pl - es); + yswap(pl, pl - es); return; } pm = (char *)a + (n / 2) * es; @@ -110,7 +108,7 @@ loop: SWAPINIT(a, es); } pm = med3(pl, pm, pn, cmp); } - swap(a, pm); + yswap(a, pm); pa = pb = (char *)a + es; pc = pd = (char *)a + (n - 1) * es; @@ -118,7 +116,7 @@ loop: SWAPINIT(a, es); while (pb <= pc && (r = cmp(pb, a)) <= 0) { if (r == 0) { swap_cnt = 1; - swap(pa, pb); + yswap(pa, pb); pa += es; } pb += es; @@ -126,14 +124,14 @@ loop: SWAPINIT(a, es); while (pb <= pc && (r = cmp(pc, a)) >= 0) { if (r == 0) { swap_cnt = 1; - swap(pc, pd); + yswap(pc, pd); pd -= es; } pc -= es; } if (pb > pc) break; - swap(pb, pc); + yswap(pb, pc); swap_cnt = 1; pb += es; pc -= es; @@ -142,7 +140,7 @@ loop: SWAPINIT(a, es); for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es) for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; pl -= es) - swap(pl, pl - es); + yswap(pl, pl - es); return; } @@ -151,9 +149,11 @@ loop: SWAPINIT(a, es); vecswap(a, pb - r, r); r = min((long)(pd - pc), (long)(pn - pd - es)); vecswap(pb, pn - r, r); - if ((r = pb - pa) > es) + r = pb - pa; + if (r > es) yaffs_qsort(a, r / es, es, cmp); - if ((r = pd - pc) > es) { + r = pd - pc; + if (r > es) { /* Iterate rather than recurse to save stack space */ a = pn - r; n = r / es; diff --git a/fs/yaffs2/yaffs_qsort.h b/fs/yaffs2/yaffs_qsort.h deleted file mode 100644 index 19083da..0000000 --- a/fs/yaffs2/yaffs_qsort.h +++ /dev/null @@ -1,23 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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__ - -extern void yaffs_qsort (void *const base, size_t total_elems, size_t size, - int (*cmp)(const void *, const void *)); - -#endif diff --git a/fs/yaffs2/yaffs_ramdisk.h b/fs/yaffs2/yaffs_ramdisk.h deleted file mode 100644 index 3cff8be..0000000 --- a/fs/yaffs2/yaffs_ramdisk.h +++ /dev/null @@ -1,32 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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. - */ - -/* - * yaffs_ramdisk.h: yaffs ram disk component - */ - -#ifndef __YAFFS_RAMDISK_H__ -#define __YAFFS_RAMDISK_H__ - - -#include "yaffs_guts.h" -int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int yramdisk_WriteChunkWithTagsToNAND(yaffs_Device *dev,int chunkInNAND,const __u8 *data, yaffs_ExtendedTags *tags); -int yramdisk_ReadChunkWithTagsFromNAND(yaffs_Device *dev,int chunkInNAND, __u8 *data, yaffs_ExtendedTags *tags); -int yramdisk_EraseBlockInNAND(yaffs_Device *dev, int blockNumber); -int yramdisk_InitialiseNAND(yaffs_Device *dev); -int yramdisk_MarkNANDBlockBad(yaffs_Device *dev,int blockNumber); -int yramdisk_QueryNANDBlock(yaffs_Device *dev, int blockNo, yaffs_BlockState *state, int *sequenceNumber); -#endif diff --git a/fs/yaffs2/yaffs_summary.c b/fs/yaffs2/yaffs_summary.c new file mode 100644 index 0000000..6f3c783 --- /dev/null +++ b/fs/yaffs2/yaffs_summary.c @@ -0,0 +1,313 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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. + */ + +/* Summaries write the useful part of the tags for the chunks in a block into an + * an array which is written to the last n chunks of the block. + * Reading the summaries gives all the tags for the block in one read. Much + * faster. + * + * Chunks holding summaries are marked with tags making it look like + * they are part of a fake file. + * + * The summary could also be used during gc. + * + */ + +#include "yaffs_summary.h" +#include "yaffs_packedtags2.h" +#include "yaffs_nand.h" +#include "yaffs_getblockinfo.h" +#include "yaffs_bitmap.h" + +/* + * The summary is built up in an array of summary tags. + * This gets written to the last one or two (maybe more) chunks in a block. + * A summary header is written as the first part of each chunk of summary data. + * The summary header must match or the summary is rejected. + */ + +/* Summary tags don't need the sequence number because that is redundant. */ +struct yaffs_summary_tags { + unsigned obj_id; + unsigned chunk_id; + unsigned n_bytes; +}; + +/* Summary header */ +struct yaffs_summary_header { + unsigned version; /* Must match current version */ + unsigned block; /* Must be this block */ + unsigned seq; /* Must be this sequence number */ + unsigned sum; /* Just add up all the bytes in the tags */ +}; + + +static void yaffs_summary_clear(struct yaffs_dev *dev) +{ + if (!dev->sum_tags) + return; + memset(dev->sum_tags, 0, dev->chunks_per_summary * + sizeof(struct yaffs_summary_tags)); +} + + +void yaffs_summary_deinit(struct yaffs_dev *dev) +{ + kfree(dev->sum_tags); + dev->sum_tags = NULL; + kfree(dev->gc_sum_tags); + dev->gc_sum_tags = NULL; + dev->chunks_per_summary = 0; +} + +int yaffs_summary_init(struct yaffs_dev *dev) +{ + int sum_bytes; + int chunks_used; /* Number of chunks used by summary */ + int sum_tags_bytes; + + sum_bytes = dev->param.chunks_per_block * + sizeof(struct yaffs_summary_tags); + + chunks_used = (sum_bytes + dev->data_bytes_per_chunk - 1)/ + (dev->data_bytes_per_chunk - + sizeof(struct yaffs_summary_header)); + + dev->chunks_per_summary = dev->param.chunks_per_block - chunks_used; + sum_tags_bytes = sizeof(struct yaffs_summary_tags) * + dev->chunks_per_summary; + dev->sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS); + dev->gc_sum_tags = kmalloc(sum_tags_bytes, GFP_NOFS); + if (!dev->sum_tags || !dev->gc_sum_tags) { + yaffs_summary_deinit(dev); + return YAFFS_FAIL; + } + + yaffs_summary_clear(dev); + + return YAFFS_OK; +} + +static unsigned yaffs_summary_sum(struct yaffs_dev *dev) +{ + u8 *sum_buffer = (u8 *)dev->sum_tags; + int i; + unsigned sum = 0; + + i = sizeof(struct yaffs_summary_tags) * + dev->chunks_per_summary; + while (i > 0) { + sum += *sum_buffer; + sum_buffer++; + i--; + } + + return sum; +} + +static int yaffs_summary_write(struct yaffs_dev *dev, int blk) +{ + struct yaffs_ext_tags tags; + u8 *buffer; + u8 *sum_buffer = (u8 *)dev->sum_tags; + int n_bytes; + int chunk_in_nand; + int chunk_in_block; + int result; + int this_tx; + struct yaffs_summary_header hdr; + int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr); + struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk); + + buffer = yaffs_get_temp_buffer(dev); + n_bytes = sizeof(struct yaffs_summary_tags) * + dev->chunks_per_summary; + memset(&tags, 0, sizeof(struct yaffs_ext_tags)); + tags.obj_id = YAFFS_OBJECTID_SUMMARY; + tags.chunk_id = 1; + chunk_in_block = dev->chunks_per_summary; + chunk_in_nand = dev->alloc_block * dev->param.chunks_per_block + + dev->chunks_per_summary; + hdr.version = YAFFS_SUMMARY_VERSION; + hdr.block = blk; + hdr.seq = bi->seq_number; + hdr.sum = yaffs_summary_sum(dev); + + do { + this_tx = n_bytes; + if (this_tx > sum_bytes_per_chunk) + this_tx = sum_bytes_per_chunk; + memcpy(buffer, &hdr, sizeof(hdr)); + memcpy(buffer + sizeof(hdr), sum_buffer, this_tx); + tags.n_bytes = this_tx + sizeof(hdr); + result = yaffs_wr_chunk_tags_nand(dev, chunk_in_nand, + buffer, &tags); + + if (result != YAFFS_OK) + break; + yaffs_set_chunk_bit(dev, blk, chunk_in_block); + bi->pages_in_use++; + dev->n_free_chunks--; + + n_bytes -= this_tx; + sum_buffer += this_tx; + chunk_in_nand++; + chunk_in_block++; + tags.chunk_id++; + } while (result == YAFFS_OK && n_bytes > 0); + yaffs_release_temp_buffer(dev, buffer); + + + if (result == YAFFS_OK) + bi->has_summary = 1; + + + return result; +} + +int yaffs_summary_read(struct yaffs_dev *dev, + struct yaffs_summary_tags *st, + int blk) +{ + struct yaffs_ext_tags tags; + u8 *buffer; + u8 *sum_buffer = (u8 *)st; + int n_bytes; + int chunk_id; + int chunk_in_nand; + int chunk_in_block; + int result; + int this_tx; + struct yaffs_summary_header hdr; + struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk); + int sum_bytes_per_chunk = dev->data_bytes_per_chunk - sizeof(hdr); + int sum_tags_bytes; + + sum_tags_bytes = sizeof(struct yaffs_summary_tags) * + dev->chunks_per_summary; + buffer = yaffs_get_temp_buffer(dev); + n_bytes = sizeof(struct yaffs_summary_tags) * dev->chunks_per_summary; + chunk_in_block = dev->chunks_per_summary; + chunk_in_nand = blk * dev->param.chunks_per_block + + dev->chunks_per_summary; + chunk_id = 1; + do { + this_tx = n_bytes; + if (this_tx > sum_bytes_per_chunk) + this_tx = sum_bytes_per_chunk; + result = yaffs_rd_chunk_tags_nand(dev, chunk_in_nand, + buffer, &tags); + + if (tags.chunk_id != chunk_id || + tags.obj_id != YAFFS_OBJECTID_SUMMARY || + tags.chunk_used == 0 || + tags.ecc_result > YAFFS_ECC_RESULT_FIXED || + tags.n_bytes != (this_tx + sizeof(hdr))) + result = YAFFS_FAIL; + if (result != YAFFS_OK) + break; + + if (st == dev->sum_tags) { + /* If we're scanning then update the block info */ + yaffs_set_chunk_bit(dev, blk, chunk_in_block); + bi->pages_in_use++; + } + memcpy(&hdr, buffer, sizeof(hdr)); + memcpy(sum_buffer, buffer + sizeof(hdr), this_tx); + n_bytes -= this_tx; + sum_buffer += this_tx; + chunk_in_nand++; + chunk_in_block++; + chunk_id++; + } while (result == YAFFS_OK && n_bytes > 0); + yaffs_release_temp_buffer(dev, buffer); + + if (result == YAFFS_OK) { + /* Verify header */ + if (hdr.version != YAFFS_SUMMARY_VERSION || + hdr.block != blk || + hdr.seq != bi->seq_number || + hdr.sum != yaffs_summary_sum(dev)) + result = YAFFS_FAIL; + } + + if (st == dev->sum_tags && result == YAFFS_OK) + bi->has_summary = 1; + + return result; +} + +int yaffs_summary_add(struct yaffs_dev *dev, + struct yaffs_ext_tags *tags, + int chunk_in_nand) +{ + struct yaffs_packed_tags2_tags_only tags_only; + struct yaffs_summary_tags *sum_tags; + int block_in_nand = chunk_in_nand / dev->param.chunks_per_block; + int chunk_in_block = chunk_in_nand % dev->param.chunks_per_block; + + if (!dev->sum_tags) + return YAFFS_OK; + + if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) { + yaffs_pack_tags2_tags_only(&tags_only, tags); + sum_tags = &dev->sum_tags[chunk_in_block]; + sum_tags->chunk_id = tags_only.chunk_id; + sum_tags->n_bytes = tags_only.n_bytes; + sum_tags->obj_id = tags_only.obj_id; + + if (chunk_in_block == dev->chunks_per_summary - 1) { + /* Time to write out the summary */ + yaffs_summary_write(dev, block_in_nand); + yaffs_summary_clear(dev); + yaffs_skip_rest_of_block(dev); + } + } + return YAFFS_OK; +} + +int yaffs_summary_fetch(struct yaffs_dev *dev, + struct yaffs_ext_tags *tags, + int chunk_in_block) +{ + struct yaffs_packed_tags2_tags_only tags_only; + struct yaffs_summary_tags *sum_tags; + if (chunk_in_block >= 0 && chunk_in_block < dev->chunks_per_summary) { + sum_tags = &dev->sum_tags[chunk_in_block]; + tags_only.chunk_id = sum_tags->chunk_id; + tags_only.n_bytes = sum_tags->n_bytes; + tags_only.obj_id = sum_tags->obj_id; + yaffs_unpack_tags2_tags_only(tags, &tags_only); + return YAFFS_OK; + } + return YAFFS_FAIL; +} + +void yaffs_summary_gc(struct yaffs_dev *dev, int blk) +{ + struct yaffs_block_info *bi = yaffs_get_block_info(dev, blk); + int i; + + if (!bi->has_summary) + return; + + for (i = dev->chunks_per_summary; + i < dev->param.chunks_per_block; + i++) { + if (yaffs_check_chunk_bit(dev, blk, i)) { + yaffs_clear_chunk_bit(dev, blk, i); + bi->pages_in_use--; + dev->n_free_chunks++; + } + } +} diff --git a/fs/yaffs2/yaffs_summary.h b/fs/yaffs2/yaffs_summary.h new file mode 100644 index 0000000..be141d0 --- /dev/null +++ b/fs/yaffs2/yaffs_summary.h @@ -0,0 +1,37 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_SUMMARY_H__ +#define __YAFFS_SUMMARY_H__ + +#include "yaffs_packedtags2.h" + + +int yaffs_summary_init(struct yaffs_dev *dev); +void yaffs_summary_deinit(struct yaffs_dev *dev); + +int yaffs_summary_add(struct yaffs_dev *dev, + struct yaffs_ext_tags *tags, + int chunk_in_block); +int yaffs_summary_fetch(struct yaffs_dev *dev, + struct yaffs_ext_tags *tags, + int chunk_in_block); +int yaffs_summary_read(struct yaffs_dev *dev, + struct yaffs_summary_tags *st, + int blk); +void yaffs_summary_gc(struct yaffs_dev *dev, int blk); + + +#endif diff --git a/fs/yaffs2/yaffs_tagscompat.c b/fs/yaffs2/yaffs_tagscompat.c index e872323..9ac5896 100644 --- a/fs/yaffs2/yaffs_tagscompat.c +++ b/fs/yaffs2/yaffs_tagscompat.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -11,63 +11,27 @@ * published by the Free Software Foundation. */ -/* XXX U-BOOT XXX */ -#include <common.h> - #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(struct yaffs_dev *dev, int nand_chunk); -static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND); -#ifdef NOTYET -static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND); -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, - const yaffs_Spare * spare); -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND, - const yaffs_Spare * spare); -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND); -#endif - -static const char yaffs_countBitsTable[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_CountBits(__u8 x) -{ - int retVal; - retVal = yaffs_countBitsTable[x]; - return retVal; -} /********** Tags ECC calculations *********/ -void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare) +void yaffs_calc_ecc(const u8 *data, struct yaffs_spare *spare) { - yaffs_ECCCalculate(data, spare->ecc1); - yaffs_ECCCalculate(&data[256], spare->ecc2); + yaffs_ecc_calc(data, spare->ecc1); + yaffs_ecc_calc(&data[256], spare->ecc2); } -void yaffs_CalcTagsECC(yaffs_Tags * tags) +void yaffs_calc_tags_ecc(struct yaffs_tags *tags) { /* Calculate an ecc */ - - unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; unsigned i, j; unsigned ecc = 0; unsigned bit = 0; @@ -77,34 +41,31 @@ void yaffs_CalcTagsECC(yaffs_Tags * tags) for (i = 0; i < 8; i++) { for (j = 1; j & 0xff; j <<= 1) { bit++; - if (b[i] & j) { + if (b[i] & j) ecc ^= bit; - } } } - tags->ecc = ecc; - } -int yaffs_CheckECCOnTags(yaffs_Tags * tags) +int yaffs_check_tags_ecc(struct yaffs_tags *tags) { unsigned ecc = tags->ecc; - yaffs_CalcTagsECC(tags); + yaffs_calc_tags_ecc(tags); ecc ^= tags->ecc; if (ecc && ecc <= 64) { /* TODO: Handle the failure better. Retire? */ - unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes; + unsigned char *b = ((union yaffs_tags_union *)tags)->as_bytes; ecc--; b[ecc / 8] ^= (1 << (ecc & 7)); /* Now recvalc the ecc */ - yaffs_CalcTagsECC(tags); + yaffs_calc_tags_ecc(tags); return 1; /* recovered error */ } else if (ecc) { @@ -112,235 +73,202 @@ int yaffs_CheckECCOnTags(yaffs_Tags * tags) /* TODO Need to do somethiong here */ return -1; /* unrecovered error */ } - return 0; } /********** Tags **********/ -static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr, - yaffs_Tags * tagsPtr) +static void yaffs_load_tags_to_spare(struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { - yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr; - - yaffs_CalcTagsECC(tagsPtr); - - sparePtr->tagByte0 = tu->asBytes[0]; - sparePtr->tagByte1 = tu->asBytes[1]; - sparePtr->tagByte2 = tu->asBytes[2]; - sparePtr->tagByte3 = tu->asBytes[3]; - sparePtr->tagByte4 = tu->asBytes[4]; - sparePtr->tagByte5 = tu->asBytes[5]; - sparePtr->tagByte6 = tu->asBytes[6]; - sparePtr->tagByte7 = tu->asBytes[7]; + union yaffs_tags_union *tu = (union yaffs_tags_union *)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_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr, - yaffs_TagsUnion *tu) +static void yaffs_get_tags_from_spare(struct yaffs_dev *dev, + struct yaffs_spare *spare_ptr, + struct yaffs_tags *tags_ptr) { + union yaffs_tags_union *tu = (union yaffs_tags_union *)tags_ptr; int result; - tu->asBytes[0] = sparePtr->tagByte0; - tu->asBytes[1] = sparePtr->tagByte1; - tu->asBytes[2] = sparePtr->tagByte2; - tu->asBytes[3] = sparePtr->tagByte3; - tu->asBytes[4] = sparePtr->tagByte4; - tu->asBytes[5] = sparePtr->tagByte5; - tu->asBytes[6] = sparePtr->tagByte6; - tu->asBytes[7] = sparePtr->tagByte7; - - result = yaffs_CheckECCOnTags(&tu->asTags); - if (result > 0) { - dev->tagsEccFixed++; - } else if (result < 0) { - dev->tagsEccUnfixed++; - } + 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_SpareInitialise(yaffs_Spare * spare) +static void yaffs_spare_init(struct yaffs_spare *spare) { - memset(spare, 0xFF, sizeof(yaffs_Spare)); + memset(spare, 0xff, sizeof(struct yaffs_spare)); } -static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, const __u8 * data, - yaffs_Spare * spare) +static int yaffs_wr_nand(struct yaffs_dev *dev, + int nand_chunk, const u8 *data, + struct yaffs_spare *spare) { - if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) { - T(YAFFS_TRACE_ERROR, - (TSTR("**>> yaffs chunk %d is not valid" TENDSTR), - chunkInNAND)); + if (nand_chunk < dev->param.start_block * dev->param.chunks_per_block) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>> yaffs chunk %d is not valid", + nand_chunk); return YAFFS_FAIL; } - dev->nPageWrites++; - return dev->writeChunkToNAND(dev, chunkInNAND, data, spare); + return dev->param.write_chunk_fn(dev, nand_chunk, data, spare); } -static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev, - int chunkInNAND, - __u8 * data, - yaffs_Spare * spare, - yaffs_ECCResult * eccResult, - int doErrorCorrection) +static int yaffs_rd_chunk_nand(struct yaffs_dev *dev, + int nand_chunk, + u8 *data, + struct yaffs_spare *spare, + enum yaffs_ecc_result *ecc_result, + int correct_errors) { - int retVal; - yaffs_Spare localSpare; - - dev->nPageReads++; + int ret_val; + struct yaffs_spare local_spare; - if (!spare && data) { + if (!spare) { /* If we don't have a real spare, then we use a local one. */ /* Need this for the calculation of the ecc */ - spare = &localSpare; + spare = &local_spare; } - if (!dev->useNANDECC) { - retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, spare); - if (data && doErrorCorrection) { + 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 eccResult1, eccResult2; - __u8 calcEcc[3]; - - yaffs_ECCCalculate(data, calcEcc); - eccResult1 = - yaffs_ECCCorrect(data, spare->ecc1, calcEcc); - yaffs_ECCCalculate(&data[256], calcEcc); - eccResult2 = - yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc); - - if (eccResult1 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error fix performed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult1 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + int ecc_result1, ecc_result2; + u8 calc_ecc[3]; + + yaffs_ecc_calc(data, calc_ecc); + ecc_result1 = + yaffs_ecc_correct(data, spare->ecc1, calc_ecc); + yaffs_ecc_calc(&data[256], calc_ecc); + ecc_result2 = + yaffs_ecc_correct(&data[256], spare->ecc2, + calc_ecc); + + if (ecc_result1 > 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error fix performed on chunk %d:0", + nand_chunk); + dev->n_ecc_fixed++; + } else if (ecc_result1 < 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error unfixed on chunk %d:0", + nand_chunk); + dev->n_ecc_unfixed++; } - if (eccResult2 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccFixed++; - } else if (eccResult2 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>yaffs ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); - dev->eccUnfixed++; + if (ecc_result2 > 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error fix performed on chunk %d:1", + nand_chunk); + dev->n_ecc_fixed++; + } else if (ecc_result2 < 0) { + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>yaffs ecc error unfixed on chunk %d:1", + nand_chunk); + dev->n_ecc_unfixed++; } - if (eccResult1 || eccResult2) { + if (ecc_result1 || ecc_result2) { /* We had a data problem on this page */ - yaffs_HandleReadDataError(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } - if (eccResult1 < 0 || eccResult2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; - else if (eccResult1 > 0 || eccResult2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + 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 - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } else { /* Must allocate enough memory for spare+2*sizeof(int) */ /* for ecc results from device. */ - struct yaffs_NANDSpare nspare; - retVal = - dev->readChunkFromNAND(dev, chunkInNAND, data, - (yaffs_Spare *) & nspare); - memcpy(spare, &nspare, sizeof(yaffs_Spare)); - if (data && doErrorCorrection) { + struct yaffs_nand_spare nspare; + + memset(&nspare, 0, sizeof(nspare)); + + ret_val = dev->param.read_chunk_fn(dev, nand_chunk, data, + (struct yaffs_spare *) + &nspare); + memcpy(spare, &nspare, sizeof(struct 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), chunkInNAND)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error fix performed on chunk %d:0", + nand_chunk); } else if (nspare.eccres1 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error unfixed on chunk %d:0" - TENDSTR), chunkInNAND)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error unfixed on chunk %d:0", + nand_chunk); } if (nspare.eccres2 > 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error fix performed on chunk %d:1" - TENDSTR), chunkInNAND)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error fix performed on chunk %d:1", + nand_chunk); } else if (nspare.eccres2 < 0) { - T(YAFFS_TRACE_ERROR, - (TSTR - ("**>>mtd ecc error unfixed on chunk %d:1" - TENDSTR), chunkInNAND)); + yaffs_trace(YAFFS_TRACE_ERROR, + "**>>mtd ecc error unfixed on chunk %d:1", + nand_chunk); } if (nspare.eccres1 || nspare.eccres2) { /* We had a data problem on this page */ - yaffs_HandleReadDataError(dev, chunkInNAND); + yaffs_handle_rd_data_error(dev, nand_chunk); } if (nspare.eccres1 < 0 || nspare.eccres2 < 0) - *eccResult = YAFFS_ECC_RESULT_UNFIXED; + *ecc_result = YAFFS_ECC_RESULT_UNFIXED; else if (nspare.eccres1 > 0 || nspare.eccres2 > 0) - *eccResult = YAFFS_ECC_RESULT_FIXED; + *ecc_result = YAFFS_ECC_RESULT_FIXED; else - *eccResult = YAFFS_ECC_RESULT_NO_ERROR; + *ecc_result = YAFFS_ECC_RESULT_NO_ERROR; } } - return retVal; + return ret_val; } -#ifdef NOTYET -static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev, - int chunkInNAND) -{ - - static int init = 0; - static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK]; - static __u8 data[YAFFS_BYTES_PER_CHUNK]; - /* Might as well always allocate the larger size for */ - /* dev->useNANDECC == true; */ - static __u8 spare[sizeof(struct yaffs_NANDSpare)]; - - dev->readChunkFromNAND(dev, chunkInNAND, 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_HandleReadDataError(yaffs_Device * dev, int chunkInNAND) +static void yaffs_handle_rd_data_error(struct yaffs_dev *dev, int nand_chunk) { - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; + int flash_block = nand_chunk / dev->param.chunks_per_block; /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; - T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, - (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND)); + yaffs_get_block_info(dev, flash_block + dev->block_offset)-> + needs_retiring = 1; + yaffs_trace(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS, + "**>>Block %d marked for retirement", + flash_block); /* TODO: * Just do a garbage collection on the affected block @@ -349,184 +277,131 @@ static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND) */ } -#ifdef NOTYET -static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND) +int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 *data, const struct yaffs_ext_tags *ext_tags) { -} + struct yaffs_spare spare; + struct yaffs_tags tags; -static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND, - const __u8 * data, - const yaffs_Spare * spare) -{ -} + yaffs_spare_init(&spare); -static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND, - const yaffs_Spare * 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; -static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND) -{ - int blockInNAND = chunkInNAND / dev->nChunksPerBlock; - - /* Mark the block for retirement */ - yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1; - /* Delete the chunk */ - yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__); -} - -static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1, - const yaffs_Spare * s0, const yaffs_Spare * s1) -{ - - if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 || - s0->tagByte0 != s1->tagByte0 || - s0->tagByte1 != s1->tagByte1 || - s0->tagByte2 != s1->tagByte2 || - s0->tagByte3 != s1->tagByte3 || - s0->tagByte4 != s1->tagByte4 || - s0->tagByte5 != s1->tagByte5 || - s0->tagByte6 != s1->tagByte6 || - s0->tagByte7 != s1->tagByte7 || - 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; - } + tags.n_bytes_lsb = ext_tags->n_bytes & (1024 - 1); - return 1; -} -#endif /* NOTYET */ - -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev, - int chunkInNAND, - const __u8 * data, - const yaffs_ExtendedTags * - eTags) -{ - yaffs_Spare spare; - yaffs_Tags tags; - - yaffs_SpareInitialise(&spare); + if (dev->data_bytes_per_chunk >= 1024) + tags.n_bytes_msb = (ext_tags->n_bytes >> 10) & 3; + else + tags.n_bytes_msb = 3; - if (eTags->chunkDeleted) { - spare.pageStatus = 0; - } else { - tags.objectId = eTags->objectId; - tags.chunkId = eTags->chunkId; - tags.byteCount = eTags->byteCount; - tags.serialNumber = eTags->serialNumber; + tags.serial_number = ext_tags->serial_number; - if (!dev->useNANDECC && data) { - yaffs_CalcECC(data, &spare); - } - yaffs_LoadTagsIntoSpare(&spare, &tags); + if (!dev->param.use_nand_ecc && data) + yaffs_calc_ecc(data, &spare); + yaffs_load_tags_to_spare(&spare, &tags); } - - return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare); + return yaffs_wr_nand(dev, nand_chunk, data, &spare); } -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev, - int chunkInNAND, - __u8 * data, - yaffs_ExtendedTags * eTags) +int yaffs_tags_compat_rd(struct yaffs_dev *dev, + int nand_chunk, + u8 *data, struct yaffs_ext_tags *ext_tags) { - - yaffs_Spare spare; - yaffs_TagsUnion tags; - yaffs_ECCResult eccResult; - - static yaffs_Spare spareFF; + struct yaffs_spare spare; + struct yaffs_tags tags; + enum yaffs_ecc_result ecc_result = YAFFS_ECC_RESULT_UNKNOWN; + static struct yaffs_spare spare_ff; static int init; + int deleted; if (!init) { - memset(&spareFF, 0xFF, sizeof(spareFF)); + memset(&spare_ff, 0xff, sizeof(spare_ff)); init = 1; } - if (yaffs_ReadChunkFromNAND - (dev, chunkInNAND, data, &spare, &eccResult, 1)) { - /* eTags may be NULL */ - if (eTags) { - - int deleted = - (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0; - - eTags->chunkDeleted = deleted; - eTags->eccResult = eccResult; - eTags->blockBad = 0; /* We're reading it */ - /* therefore it is not a bad block */ - eTags->chunkUsed = - (memcmp(&spareFF, &spare, sizeof(spareFF)) != - 0) ? 1 : 0; - - if (eTags->chunkUsed) { - yaffs_GetTagsFromSpare(dev, &spare, &tags); - - eTags->objectId = tags.asTags.objectId; - eTags->chunkId = tags.asTags.chunkId; - eTags->byteCount = tags.asTags.byteCount; - eTags->serialNumber = tags.asTags.serialNumber; - } - } + if (!yaffs_rd_chunk_nand(dev, nand_chunk, + data, &spare, &ecc_result, 1)) + return YAFFS_FAIL; + /* ext_tags may be NULL */ + if (!ext_tags) return YAFFS_OK; - } else { - return YAFFS_FAIL; + + deleted = (hweight8(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)) ? 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; } -int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, - int blockInNAND) +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int flash_block) { + struct yaffs_spare spare; - yaffs_Spare spare; - - memset(&spare, 0xff, sizeof(yaffs_Spare)); + memset(&spare, 0xff, sizeof(struct yaffs_spare)); - spare.blockStatus = 'Y'; + spare.block_status = 'Y'; - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock, NULL, - &spare); - yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock + 1, - NULL, &spare); + 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_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, - int blockNo, yaffs_BlockState * - state, - int *sequenceNumber) +int yaffs_tags_compat_query_block(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 *seq_number) { - - yaffs_Spare spare0, spare1; - static yaffs_Spare spareFF; + struct yaffs_spare spare0, spare1; + static struct yaffs_spare spare_ff; static int init; - yaffs_ECCResult dummy; + enum yaffs_ecc_result dummy; if (!init) { - memset(&spareFF, 0xFF, sizeof(spareFF)); + memset(&spare_ff, 0xff, sizeof(spare_ff)); init = 1; } - *sequenceNumber = 0; + *seq_number = 0; - yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock, NULL, - &spare0, &dummy, 1); - yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock + 1, NULL, - &spare1, &dummy, 1); + 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_CountBits(spare0.blockStatus & spare1.blockStatus) < 7) + if (hweight8(spare0.block_status & spare1.block_status) < 7) *state = YAFFS_BLOCK_STATE_DEAD; - else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0) + else if (memcmp(&spare_ff, &spare0, sizeof(spare_ff)) == 0) *state = YAFFS_BLOCK_STATE_EMPTY; else - *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING; + *state = YAFFS_BLOCK_STATE_NEEDS_SCAN; return YAFFS_OK; } diff --git a/fs/yaffs2/yaffs_tagscompat.h b/fs/yaffs2/yaffs_tagscompat.h index a61e3ba..b3c6655 100644 --- a/fs/yaffs2/yaffs_tagscompat.h +++ b/fs/yaffs2/yaffs_tagscompat.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -17,24 +17,20 @@ #define __YAFFS_TAGSCOMPAT_H__ #include "yaffs_guts.h" -int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev, - int chunkInNAND, - const __u8 * data, - const yaffs_ExtendedTags * - tags); -int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev, - int chunkInNAND, - __u8 * data, - yaffs_ExtendedTags * - tags); -int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev, - int blockNo); -int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev, - int blockNo, yaffs_BlockState * - state, int *sequenceNumber); +int yaffs_tags_compat_wr(struct yaffs_dev *dev, + int nand_chunk, + const u8 *data, const struct yaffs_ext_tags *tags); +int yaffs_tags_compat_rd(struct yaffs_dev *dev, + int nand_chunk, + u8 *data, struct yaffs_ext_tags *tags); +int yaffs_tags_compat_mark_bad(struct yaffs_dev *dev, int block_no); +int yaffs_tags_compat_query_block(struct yaffs_dev *dev, + int block_no, + enum yaffs_block_state *state, + u32 *seq_number); -void yaffs_CalcTagsECC(yaffs_Tags * tags); -int yaffs_CheckECCOnTags(yaffs_Tags * tags); -int yaffs_CountBits(__u8 byte); +void yaffs_calc_tags_ecc(struct yaffs_tags *tags); +int yaffs_check_tags_ecc(struct yaffs_tags *tags); +int yaffs_count_bits(u8 byte); #endif diff --git a/fs/yaffs2/yaffs_tagsvalidity.c b/fs/yaffs2/yaffs_tagsvalidity.c deleted file mode 100644 index f588d3a..0000000 --- a/fs/yaffs2/yaffs_tagsvalidity.c +++ /dev/null @@ -1,31 +0,0 @@ -/* - * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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. - */ - -/* XXX U-BOOT XXX */ -#include <common.h> - -#include "yaffs_tagsvalidity.h" - -void yaffs_InitialiseTags(yaffs_ExtendedTags * tags) -{ - memset(tags, 0, sizeof(yaffs_ExtendedTags)); - tags->validMarker0 = 0xAAAAAAAA; - tags->validMarker1 = 0x55555555; -} - -int yaffs_ValidateTags(yaffs_ExtendedTags * tags) -{ - return (tags->validMarker0 == 0xAAAAAAAA && - tags->validMarker1 == 0x55555555); - -} diff --git a/fs/yaffs2/yaffs_tagsvalidity.h b/fs/yaffs2/yaffs_tagsvalidity.h deleted file mode 100644 index 2fd0c24..0000000 --- a/fs/yaffs2/yaffs_tagsvalidity.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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_InitialiseTags(yaffs_ExtendedTags * tags); -int yaffs_ValidateTags(yaffs_ExtendedTags * tags); -#endif diff --git a/fs/yaffs2/yaffs_trace.h b/fs/yaffs2/yaffs_trace.h new file mode 100644 index 0000000..fd26054 --- /dev/null +++ b/fs/yaffs2/yaffs_trace.h @@ -0,0 +1,57 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_MOUNT 0x00800000 + +#define YAFFS_TRACE_ERROR 0x40000000 +#define YAFFS_TRACE_BUG 0x80000000 +#define YAFFS_TRACE_ALWAYS 0xf0000000 + +#endif diff --git a/fs/yaffs2/yaffs_uboot_glue.c b/fs/yaffs2/yaffs_uboot_glue.c new file mode 100644 index 0000000..e113e40 --- /dev/null +++ b/fs/yaffs2/yaffs_uboot_glue.c @@ -0,0 +1,464 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2007 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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. + */ + +/* + * yaffscfg.c The configuration for the "direct" use of yaffs. + * + * This is set up for u-boot. + * + * This version now uses the ydevconfig mechanism to set up partitions. + */ + +#include <common.h> + +#include <config.h> +#include "nand.h" +#include "yaffscfg.h" +#include "yaffsfs.h" +#include "yaffs_packedtags2.h" +#include "yaffs_mtdif.h" +#include "yaffs_mtdif2.h" +#if 0 +#include <errno.h> +#else +#include "malloc.h" +#endif + +unsigned yaffs_trace_mask = 0x0; /* Disable logging */ +static int yaffs_errno; + + +void yaffs_bug_fn(const char *fn, int n) +{ + printf("yaffs bug at %s:%d\n", fn, n); +} + +void *yaffsfs_malloc(size_t x) +{ + return malloc(x); +} + +void yaffsfs_free(void *x) +{ + free(x); +} + +void yaffsfs_SetError(int err) +{ + yaffs_errno = err; +} + +int yaffsfs_GetLastError(void) +{ + return yaffs_errno; +} + + +int yaffsfs_GetError(void) +{ + return yaffs_errno; +} + +void yaffsfs_Lock(void) +{ +} + +void yaffsfs_Unlock(void) +{ +} + +__u32 yaffsfs_CurrentTime(void) +{ + return 0; +} + +void *yaffs_malloc(size_t size) +{ + return malloc(size); +} + +void yaffs_free(void *ptr) +{ + free(ptr); +} + +void yaffsfs_LocalInitialisation(void) +{ + /* No locking used */ +} + + +static const char *yaffs_file_type_str(struct yaffs_stat *stat) +{ + switch (stat->st_mode & S_IFMT) { + case S_IFREG: return "regular file"; + case S_IFDIR: return "directory"; + case S_IFLNK: return "symlink"; + default: return "unknown"; + } +} + +static const char *yaffs_error_str(void) +{ + int error = yaffsfs_GetLastError(); + + if (error < 0) + error = -error; + + switch (error) { + case EBUSY: return "Busy"; + case ENODEV: return "No such device"; + case EINVAL: return "Invalid parameter"; + case ENFILE: return "Too many open files"; + case EBADF: return "Bad handle"; + case EACCES: return "Wrong permissions"; + case EXDEV: return "Not on same device"; + case ENOENT: return "No such entry"; + case ENOSPC: return "Device full"; + case EROFS: return "Read only file system"; + case ERANGE: return "Range error"; + case ENOTEMPTY: return "Not empty"; + case ENAMETOOLONG: return "Name too long"; + case ENOMEM: return "Out of memory"; + case EFAULT: return "Fault"; + case EEXIST: return "Name exists"; + case ENOTDIR: return "Not a directory"; + case EISDIR: return "Not permitted on a directory"; + case ELOOP: return "Symlink loop"; + case 0: return "No error"; + default: return "Unknown error"; + } +} + +extern nand_info_t nand_info[]; + +void cmd_yaffs_tracemask(unsigned set, unsigned mask) +{ + if (set) + yaffs_trace_mask = mask; + + printf("yaffs trace mask: %08x\n", yaffs_trace_mask); +} + +static int yaffs_regions_overlap(int a, int b, int x, int y) +{ + return (a <= x && x <= b) || + (a <= y && y <= b) || + (x <= a && a <= y) || + (x <= b && b <= y); +} + +void cmd_yaffs_devconfig(char *_mp, int flash_dev, + int start_block, int end_block) +{ + struct mtd_info *mtd = NULL; + struct yaffs_dev *dev = NULL; + struct yaffs_dev *chk; + char *mp = NULL; + struct nand_chip *chip; + + dev = calloc(1, sizeof(*dev)); + mp = strdup(_mp); + + mtd = &nand_info[flash_dev]; + + if (!dev || !mp) { + /* Alloc error */ + printf("Failed to allocate memory\n"); + goto err; + } + + if (flash_dev >= CONFIG_SYS_MAX_NAND_DEVICE) { + printf("Flash device invalid\n"); + goto err; + } + + if (end_block == 0) + end_block = mtd->size / mtd->erasesize - 1; + + if (end_block < start_block) { + printf("Bad start/end\n"); + goto err; + } + + chip = mtd->priv; + + /* Check for any conflicts */ + yaffs_dev_rewind(); + while (1) { + chk = yaffs_next_dev(); + if (!chk) + break; + if (strcmp(chk->param.name, mp) == 0) { + printf("Mount point name already used\n"); + goto err; + } + if (chk->driver_context == mtd && + yaffs_regions_overlap( + chk->param.start_block, chk->param.end_block, + start_block, end_block)) { + printf("Region overlaps with partition %s\n", + chk->param.name); + goto err; + } + + } + + /* Seems sane, so configure */ + memset(dev, 0, sizeof(*dev)); + dev->param.name = mp; + dev->driver_context = mtd; + dev->param.start_block = start_block; + dev->param.end_block = end_block; + dev->param.chunks_per_block = mtd->erasesize / mtd->writesize; + dev->param.total_bytes_per_chunk = mtd->writesize; + dev->param.is_yaffs2 = 1; + dev->param.use_nand_ecc = 1; + dev->param.n_reserved_blocks = 5; + if (chip->ecc.layout->oobavail < sizeof(struct yaffs_packed_tags2)) + dev->param.inband_tags = 1; + dev->param.n_caches = 10; + dev->param.write_chunk_tags_fn = nandmtd2_write_chunk_tags; + dev->param.read_chunk_tags_fn = nandmtd2_read_chunk_tags; + dev->param.erase_fn = nandmtd_EraseBlockInNAND; + dev->param.initialise_flash_fn = nandmtd_InitialiseNAND; + dev->param.bad_block_fn = nandmtd2_MarkNANDBlockBad; + dev->param.query_block_fn = nandmtd2_QueryNANDBlock; + + yaffs_add_device(dev); + + printf("Configures yaffs mount %s: dev %d start block %d, end block %d %s\n", + mp, flash_dev, start_block, end_block, + dev->param.inband_tags ? "using inband tags" : ""); + return; + +err: + free(dev); + free(mp); +} + +void cmd_yaffs_dev_ls(void) +{ + struct yaffs_dev *dev; + int flash_dev; + int free_space; + + yaffs_dev_rewind(); + + while (1) { + dev = yaffs_next_dev(); + if (!dev) + return; + flash_dev = + ((unsigned) dev->driver_context - (unsigned) nand_info)/ + sizeof(nand_info[0]); + printf("%-10s %5d 0x%05x 0x%05x %s", + dev->param.name, flash_dev, + dev->param.start_block, dev->param.end_block, + dev->param.inband_tags ? "using inband tags, " : ""); + + free_space = yaffs_freespace(dev->param.name); + if (free_space < 0) + printf("not mounted\n"); + else + printf("free 0x%x\n", free_space); + + } +} + +void make_a_file(char *yaffsName, char bval, int sizeOfFile) +{ + int outh; + int i; + unsigned char buffer[100]; + + outh = yaffs_open(yaffsName, + O_CREAT | O_RDWR | O_TRUNC, + S_IREAD | S_IWRITE); + if (outh < 0) { + printf("Error opening file: %d. %s\n", outh, yaffs_error_str()); + return; + } + + memset(buffer, bval, 100); + + do { + i = sizeOfFile; + if (i > 100) + i = 100; + sizeOfFile -= i; + + yaffs_write(outh, buffer, i); + + } while (sizeOfFile > 0); + + + yaffs_close(outh); +} + +void read_a_file(char *fn) +{ + int h; + int i = 0; + unsigned char b; + + h = yaffs_open(fn, O_RDWR, 0); + if (h < 0) { + printf("File not found\n"); + return; + } + + while (yaffs_read(h, &b, 1) > 0) { + printf("%02x ", b); + i++; + if (i > 32) { + printf("\n"); + i = 0;; + } + } + printf("\n"); + yaffs_close(h); +} + +void cmd_yaffs_mount(char *mp) +{ + int retval = yaffs_mount(mp); + if (retval < 0) + printf("Error mounting %s, return value: %d, %s\n", mp, + yaffsfs_GetError(), yaffs_error_str()); +} + + +void cmd_yaffs_umount(char *mp) +{ + if (yaffs_unmount(mp) == -1) + printf("Error umounting %s, return value: %d, %s\n", mp, + yaffsfs_GetError(), yaffs_error_str()); +} + +void cmd_yaffs_write_file(char *yaffsName, char bval, int sizeOfFile) +{ + make_a_file(yaffsName, bval, sizeOfFile); +} + + +void cmd_yaffs_read_file(char *fn) +{ + read_a_file(fn); +} + + +void cmd_yaffs_mread_file(char *fn, char *addr) +{ + int h; + struct yaffs_stat s; + + yaffs_stat(fn, &s); + + printf("Copy %s to 0x%p... ", fn, addr); + h = yaffs_open(fn, O_RDWR, 0); + if (h < 0) { + printf("File not found\n"); + return; + } + + yaffs_read(h, addr, (int)s.st_size); + printf("\t[DONE]\n"); + + yaffs_close(h); +} + + +void cmd_yaffs_mwrite_file(char *fn, char *addr, int size) +{ + int outh; + + outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); + if (outh < 0) + printf("Error opening file: %d, %s\n", outh, yaffs_error_str()); + + yaffs_write(outh, addr, size); + + yaffs_close(outh); +} + + +void cmd_yaffs_ls(const char *mountpt, int longlist) +{ + int i; + yaffs_DIR *d; + struct yaffs_dirent *de; + struct yaffs_stat stat; + char tempstr[255]; + + d = yaffs_opendir(mountpt); + + if (!d) { + printf("opendir failed, %s\n", yaffs_error_str()); + return; + } + + for (i = 0; (de = yaffs_readdir(d)) != NULL; i++) { + if (longlist) { + sprintf(tempstr, "%s/%s", mountpt, de->d_name); + yaffs_lstat(tempstr, &stat); + printf("%-25s\t%7ld", + de->d_name, + (long)stat.st_size); + printf(" %5d %s\n", + stat.st_ino, + yaffs_file_type_str(&stat)); + } else { + printf("%s\n", de->d_name); + } + } + + yaffs_closedir(d); +} + + +void cmd_yaffs_mkdir(const char *dir) +{ + int retval = yaffs_mkdir(dir, 0); + + if (retval < 0) + printf("yaffs_mkdir returning error: %d, %s\n", + retval, yaffs_error_str()); +} + +void cmd_yaffs_rmdir(const char *dir) +{ + int retval = yaffs_rmdir(dir); + + if (retval < 0) + printf("yaffs_rmdir returning error: %d, %s\n", + retval, yaffs_error_str()); +} + +void cmd_yaffs_rm(const char *path) +{ + int retval = yaffs_unlink(path); + + if (retval < 0) + printf("yaffs_unlink returning error: %d, %s\n", + retval, yaffs_error_str()); +} + +void cmd_yaffs_mv(const char *oldPath, const char *newPath) +{ + int retval = yaffs_rename(newPath, oldPath); + + if (retval < 0) + printf("yaffs_unlink returning error: %d, %s\n", + retval, yaffs_error_str()); +} diff --git a/fs/yaffs2/yaffs_verify.c b/fs/yaffs2/yaffs_verify.c new file mode 100644 index 0000000..db48e56 --- /dev/null +++ b/fs/yaffs2/yaffs_verify.c @@ -0,0 +1,529 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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(struct yaffs_dev *dev) +{ + dev = dev; + return !(yaffs_trace_mask & + (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL)); +} + +static int yaffs_skip_full_verification(struct yaffs_dev *dev) +{ + dev = dev; + return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_FULL)); +} + +static int yaffs_skip_nand_verification(struct yaffs_dev *dev) +{ + dev = dev; + return !(yaffs_trace_mask & (YAFFS_TRACE_VERIFY_NAND)); +} + +static const char * const block_state_name[] = { + "Unknown", + "Needs scan", + "Scanning", + "Empty", + "Allocating", + "Full", + "Dirty", + "Checkpoint", + "Collecting", + "Dead" +}; + +void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *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) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Block %d has undefined state %d", + n, bi->block_state); + + switch (bi->block_state) { + case YAFFS_BLOCK_STATE_UNKNOWN: + case YAFFS_BLOCK_STATE_SCANNING: + case YAFFS_BLOCK_STATE_NEEDS_SCAN: + yaffs_trace(YAFFS_TRACE_VERIFY, + "Block %d has bad run-state %s", + 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) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Block %d has illegal values pages_in_used %d soft_del_pages %d", + 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) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Block %d has inconsistent values pages_in_use %d counted chunk bits %d", + n, bi->pages_in_use, in_use); +} + +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n) +{ + yaffs_verify_blk(dev, bi, n); + + /* After collection the block should be in the erased state */ + + if (bi->block_state != YAFFS_BLOCK_STATE_COLLECTING && + bi->block_state != YAFFS_BLOCK_STATE_EMPTY) { + yaffs_trace(YAFFS_TRACE_ERROR, + "Block %d is in state %d after gc, should be erased", + n, bi->block_state); + } +} + +void yaffs_verify_blocks(struct yaffs_dev *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++) { + struct yaffs_block_info *bi = yaffs_get_block_info(dev, i); + yaffs_verify_blk(dev, bi, i); + + if (bi->block_state < YAFFS_NUMBER_OF_BLOCK_STATES) + state_count[bi->block_state]++; + else + illegal_states++; + } + + yaffs_trace(YAFFS_TRACE_VERIFY, "Block summary"); + + yaffs_trace(YAFFS_TRACE_VERIFY, + "%d blocks have illegal states", + illegal_states); + if (state_count[YAFFS_BLOCK_STATE_ALLOCATING] > 1) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Too many allocating blocks"); + + for (i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++) + yaffs_trace(YAFFS_TRACE_VERIFY, + "%s %d blocks", + block_state_name[i], state_count[i]); + + if (dev->blocks_in_checkpt != state_count[YAFFS_BLOCK_STATE_CHECKPOINT]) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Checkpoint block count wrong dev %d count %d", + dev->blocks_in_checkpt, + state_count[YAFFS_BLOCK_STATE_CHECKPOINT]); + + if (dev->n_erased_blocks != state_count[YAFFS_BLOCK_STATE_EMPTY]) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Erased block count wrong dev %d count %d", + dev->n_erased_blocks, + state_count[YAFFS_BLOCK_STATE_EMPTY]); + + if (state_count[YAFFS_BLOCK_STATE_COLLECTING] > 1) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Too many collecting blocks %d (max is 1)", + state_count[YAFFS_BLOCK_STATE_COLLECTING]); +} + +/* + * 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(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check) +{ + if (obj && yaffs_skip_verification(obj->my_dev)) + return; + + if (!(tags && obj && oh)) { + yaffs_trace(YAFFS_TRACE_VERIFY, + "Verifying object header tags %p obj %p oh %p", + tags, obj, oh); + return; + } + + if (oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN || + oh->type > YAFFS_OBJECT_TYPE_MAX) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d header type is illegal value 0x%x", + tags->obj_id, oh->type); + + if (tags->obj_id != obj->obj_id) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d header mismatch obj_id %d", + 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) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d header mismatch parent_id %d obj->parent is NULL", + 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)) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d header mismatch parent_id %d parent_obj_id %d", + tags->obj_id, oh->parent_obj_id, + obj->parent->obj_id); + + if (tags->obj_id > 1 && oh->name[0] == 0) /* Null name */ + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d header name is NULL", + obj->obj_id); + + if (tags->obj_id > 1 && ((u8) (oh->name[0])) == 0xff) /* Junk name */ + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d header name is 0xff", + obj->obj_id); +} + +void yaffs_verify_file(struct yaffs_obj *obj) +{ + u32 x; + int required_depth; + int actual_depth; + int last_chunk; + u32 offset_in_chunk; + u32 the_chunk; + + u32 i; + struct yaffs_dev *dev; + struct yaffs_ext_tags tags; + struct yaffs_tnode *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 */ + yaffs_addr_to_chunk(dev, obj->variant.file_variant.file_size, + &last_chunk, &offset_in_chunk); + last_chunk++; + 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) + continue; + + the_chunk = yaffs_get_group_base(dev, tn, i); + if (the_chunk > 0) { + yaffs_rd_chunk_tags_nand(dev, the_chunk, NULL, + &tags); + if (tags.obj_id != obj_id || tags.chunk_id != i) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Object %d chunk_id %d NAND mismatch chunk %d tags (%d:%d)", + obj_id, i, the_chunk, + tags.obj_id, tags.chunk_id); + } + } +} + +void yaffs_verify_link(struct yaffs_obj *obj) +{ + if (obj && yaffs_skip_verification(obj->my_dev)) + return; + + /* Verify sane equivalent object */ +} + +void yaffs_verify_symlink(struct yaffs_obj *obj) +{ + if (obj && yaffs_skip_verification(obj->my_dev)) + return; + + /* Verify symlink string */ +} + +void yaffs_verify_special(struct yaffs_obj *obj) +{ + if (obj && yaffs_skip_verification(obj->my_dev)) + return; +} + +void yaffs_verify_obj(struct yaffs_obj *obj) +{ + struct yaffs_dev *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)) + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d has chunk_id %d %s %s", + 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)) { + struct yaffs_ext_tags tags; + struct yaffs_obj_hdr *oh; + u8 *buffer = yaffs_get_temp_buffer(dev); + + oh = (struct yaffs_obj_hdr *)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); + } + + /* Verify it has a parent */ + if (obj && !obj->fake && (!obj->parent || obj->parent->my_dev != dev)) { + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d has parent pointer %p which does not look like an object", + obj->obj_id, obj->parent); + } + + /* Verify parent is a directory */ + if (obj->parent && + obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d's parent is not a directory (type %d)", + 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: + yaffs_trace(YAFFS_TRACE_VERIFY, + "Obj %d has illegaltype %d", + obj->obj_id, obj->variant_type); + break; + } +} + +void yaffs_verify_objects(struct yaffs_dev *dev) +{ + struct yaffs_obj *obj; + int i; + struct list_head *lh; + + if (yaffs_skip_verification(dev)) + return; + + /* Iterate through the objects in each hash entry */ + + for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each(lh, &dev->obj_bucket[i].list) { + obj = list_entry(lh, struct yaffs_obj, hash_link); + yaffs_verify_obj(obj); + } + } +} + +void yaffs_verify_obj_in_dir(struct yaffs_obj *obj) +{ + struct list_head *lh; + struct yaffs_obj *list_obj; + int count = 0; + + if (!obj) { + yaffs_trace(YAFFS_TRACE_ALWAYS, "No object to verify"); + BUG(); + return; + } + + if (yaffs_skip_verification(obj->my_dev)) + return; + + if (!obj->parent) { + yaffs_trace(YAFFS_TRACE_ALWAYS, "Object does not have parent"); + BUG(); + return; + } + + if (obj->parent->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_trace(YAFFS_TRACE_ALWAYS, "Parent is not directory"); + BUG(); + } + + /* Iterate through the objects in each hash entry */ + + list_for_each(lh, &obj->parent->variant.dir_variant.children) { + list_obj = list_entry(lh, struct yaffs_obj, siblings); + yaffs_verify_obj(list_obj); + if (obj == list_obj) + count++; + } + + if (count != 1) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "Object in directory %d times", + count); + BUG(); + } +} + +void yaffs_verify_dir(struct yaffs_obj *directory) +{ + struct list_head *lh; + struct yaffs_obj *list_obj; + + if (!directory) { + BUG(); + return; + } + + if (yaffs_skip_full_verification(directory->my_dev)) + return; + + if (directory->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "Directory has wrong type: %d", + directory->variant_type); + BUG(); + } + + /* Iterate through the objects in each hash entry */ + + list_for_each(lh, &directory->variant.dir_variant.children) { + list_obj = list_entry(lh, struct yaffs_obj, siblings); + if (list_obj->parent != directory) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "Object in directory list has wrong parent %p", + list_obj->parent); + BUG(); + } + yaffs_verify_obj_in_dir(list_obj); + } +} + +static int yaffs_free_verification_failures; + +void yaffs_verify_free_chunks(struct yaffs_dev *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) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "Freechunks verification failure %d %d %d", + dev->n_free_chunks, counted, difference); + yaffs_free_verification_failures++; + } +} + +int yaffs_verify_file_sane(struct yaffs_obj *in) +{ + in = in; + return YAFFS_OK; +} diff --git a/fs/yaffs2/yaffs_verify.h b/fs/yaffs2/yaffs_verify.h new file mode 100644 index 0000000..4f4af8d --- /dev/null +++ b/fs/yaffs2/yaffs_verify.h @@ -0,0 +1,43 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_VERIFY_H__ +#define __YAFFS_VERIFY_H__ + +#include "yaffs_guts.h" + +void yaffs_verify_blk(struct yaffs_dev *dev, struct yaffs_block_info *bi, + int n); +void yaffs_verify_collected_blk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, int n); +void yaffs_verify_blocks(struct yaffs_dev *dev); + +void yaffs_verify_oh(struct yaffs_obj *obj, struct yaffs_obj_hdr *oh, + struct yaffs_ext_tags *tags, int parent_check); +void yaffs_verify_file(struct yaffs_obj *obj); +void yaffs_verify_link(struct yaffs_obj *obj); +void yaffs_verify_symlink(struct yaffs_obj *obj); +void yaffs_verify_special(struct yaffs_obj *obj); +void yaffs_verify_obj(struct yaffs_obj *obj); +void yaffs_verify_objects(struct yaffs_dev *dev); +void yaffs_verify_obj_in_dir(struct yaffs_obj *obj); +void yaffs_verify_dir(struct yaffs_obj *directory); +void yaffs_verify_free_chunks(struct yaffs_dev *dev); + +int yaffs_verify_file_sane(struct yaffs_obj *obj); + +int yaffs_skip_verification(struct yaffs_dev *dev); + +#endif diff --git a/fs/yaffs2/yaffs_yaffs1.c b/fs/yaffs2/yaffs_yaffs1.c new file mode 100644 index 0000000..d277e20 --- /dev/null +++ b/fs/yaffs2/yaffs_yaffs1.c @@ -0,0 +1,422 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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" +#include "yaffs_attribs.h" + +int yaffs1_scan(struct yaffs_dev *dev) +{ + struct yaffs_ext_tags tags; + int blk; + int result; + int chunk; + int c; + int deleted; + enum yaffs_block_state state; + LIST_HEAD(hard_list); + struct yaffs_block_info *bi; + u32 seq_number; + struct yaffs_obj_hdr *oh; + struct yaffs_obj *in; + struct yaffs_obj *parent; + int alloc_failed = 0; + struct yaffs_shadow_fixer *shadow_fixers = NULL; + u8 *chunk_data; + + yaffs_trace(YAFFS_TRACE_SCAN, + "yaffs1_scan starts intstartblk %d intendblk %d...", + dev->internal_start_block, dev->internal_end_block); + + chunk_data = yaffs_get_temp_buffer(dev); + + 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; + + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, + "Block scanning block %d state %d seq %d", + blk, state, seq_number); + + if (state == YAFFS_BLOCK_STATE_DEAD) { + yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, + "block %d is bad", blk); + } else if (state == YAFFS_BLOCK_STATE_EMPTY) { + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "Block empty "); + 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++) { + + cond_resched(); + + 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_SCAN; 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++; + } 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 */ + yaffs_trace(YAFFS_TRACE_SCAN, + " Allocating from %d %d", + blk, c); + state = YAFFS_BLOCK_STATE_ALLOCATING; + dev->alloc_block = blk; + dev->alloc_page = c; + dev->alloc_block_finder = blk; + + } + + 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; + } + + } + } else { + /* chunk_id == 0, so it is an ObjectHeader. + * 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 = (struct yaffs_obj_hdr *)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 = NULL; + } + + 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 *fixer; + fixer = + kmalloc(sizeof + (struct yaffs_shadow_fixer), + GFP_NOFS); + if (fixer) { + fixer->next = shadow_fixers; + shadow_fixers = fixer; + fixer->obj_id = tags.obj_id; + fixer->shadowed_id = + oh->shadows_obj; + yaffs_trace(YAFFS_TRACE_SCAN, + " Shadow fixer: %d shadows %d", + 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; + yaffs_load_attribs(in, oh); + 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; + yaffs_load_attribs(in, oh); + 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; + INIT_LIST_HEAD(&parent-> + variant.dir_variant. + children); + } else if (!parent || + parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) { + /* Hoosterman, a problem.... + * We're trying to use a + * non-directory as a directory + */ + + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." + ); + parent = dev->lost_n_found; + } + + yaffs_add_obj_to_dir(parent, in); + + 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 + = yaffs_oh_to_size(oh); + break; + case YAFFS_OBJECT_TYPE_HARDLINK: + in->variant. + hardlink_variant.equiv_id = + oh->equiv_id; + list_add(&in->hard_links, + &hard_list); + 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_SCAN) { + /* 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. + * There should not be more than one of these. + */ + { + struct yaffs_shadow_fixer *fixer; + struct yaffs_obj *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); + + kfree(fixer); + } + } + + yaffs_release_temp_buffer(dev, chunk_data); + + if (alloc_failed) + return YAFFS_FAIL; + + yaffs_trace(YAFFS_TRACE_SCAN, "yaffs1_scan ends"); + + return YAFFS_OK; +} diff --git a/fs/yaffs2/yaffs_yaffs1.h b/fs/yaffs2/yaffs_yaffs1.h new file mode 100644 index 0000000..97e2fdd --- /dev/null +++ b/fs/yaffs2/yaffs_yaffs1.h @@ -0,0 +1,22 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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(struct yaffs_dev *dev); + +#endif diff --git a/fs/yaffs2/yaffs_yaffs2.c b/fs/yaffs2/yaffs_yaffs2.c new file mode 100644 index 0000000..f1dc972 --- /dev/null +++ b/fs/yaffs2/yaffs_yaffs2.c @@ -0,0 +1,1532 @@ +/* + * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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_nand.h" +#include "yaffs_getblockinfo.h" +#include "yaffs_verify.h" +#include "yaffs_attribs.h" +#include "yaffs_summary.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(struct yaffs_dev *dev) +{ + int i; + unsigned seq; + unsigned block_no = 0; + struct yaffs_block_info *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(struct yaffs_dev *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(struct yaffs_dev *dev, + struct yaffs_block_info *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(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *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(struct yaffs_dev *dev, struct yaffs_block_info *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(struct yaffs_dev *dev) +{ + u32 b; + u32 oldest = 0; + u32 oldest_seq = 0; + struct yaffs_block_info *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) { + yaffs_trace(YAFFS_TRACE_GC, + "GC refresh count %d selected block %d with seq_number %d", + dev->refresh_count, oldest, oldest_seq); + } + + return oldest; +} + +int yaffs2_checkpt_required(struct yaffs_dev *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(struct yaffs_dev *dev) +{ + int retval; + int n_bytes = 0; + int n_blocks; + int dev_blocks; + + if (!dev->param.is_yaffs2) + return 0; + + if (!dev->checkpoint_blocks_required && yaffs2_checkpt_required(dev)) { + /* Not a valid value so recalculate */ + dev_blocks = dev->param.end_block - dev->param.start_block + 1; + n_bytes += sizeof(struct yaffs_checkpt_validity); + n_bytes += sizeof(struct yaffs_checkpt_dev); + n_bytes += dev_blocks * sizeof(struct yaffs_block_info); + n_bytes += dev_blocks * dev->chunk_bit_stride; + n_bytes += + (sizeof(struct yaffs_checkpt_obj) + sizeof(u32)) * + dev->n_obj; + n_bytes += (dev->tnode_size + sizeof(u32)) * dev->n_tnodes; + n_bytes += sizeof(struct yaffs_checkpt_validity); + n_bytes += sizeof(u32); /* checksum */ + + /* Round up and add 2 blocks to allow for some bad blocks, + * so add 3 */ + + n_blocks = + (n_bytes / + (dev->data_bytes_per_chunk * + dev->param.chunks_per_block)) + 3; + + 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(struct yaffs_dev *dev, int head) +{ + struct yaffs_checkpt_validity 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_validity_marker(struct yaffs_dev *dev, int head) +{ + struct yaffs_checkpt_validity cp; + int ok; + + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); + + if (ok) + ok = (cp.struct_type == sizeof(cp)) && + (cp.magic == YAFFS_MAGIC) && + (cp.version == YAFFS_CHECKPOINT_VERSION) && + (cp.head == ((head) ? 1 : 0)); + return ok ? 1 : 0; +} + +static void yaffs2_dev_to_checkpt_dev(struct yaffs_checkpt_dev *cp, + struct yaffs_dev *dev) +{ + cp->n_erased_blocks = dev->n_erased_blocks; + cp->alloc_block = dev->alloc_block; + 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(struct yaffs_dev *dev, + struct yaffs_checkpt_dev *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(struct yaffs_dev *dev) +{ + struct yaffs_checkpt_dev cp; + u32 n_bytes; + u32 n_blocks = dev->internal_end_block - dev->internal_start_block + 1; + int ok; + + /* Write device runtime values */ + yaffs2_dev_to_checkpt_dev(&cp, dev); + cp.struct_type = sizeof(cp); + + ok = (yaffs2_checkpt_wr(dev, &cp, sizeof(cp)) == sizeof(cp)); + if (!ok) + return 0; + + /* Write block info */ + n_bytes = n_blocks * sizeof(struct yaffs_block_info); + ok = (yaffs2_checkpt_wr(dev, dev->block_info, n_bytes) == n_bytes); + if (!ok) + return 0; + + /* Write chunk bits */ + 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(struct yaffs_dev *dev) +{ + struct yaffs_checkpt_dev 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(struct yaffs_block_info); + + 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(struct yaffs_checkpt_obj *cp, + struct yaffs_obj *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 yaffs2_checkpt_obj_to_obj(struct yaffs_obj *obj, + struct yaffs_checkpt_obj *cp) +{ + struct yaffs_obj *parent; + + if (obj->variant_type != cp->variant_type) { + yaffs_trace(YAFFS_TRACE_ERROR, + "Checkpoint read object %d type %d chunk %d does not match existing object type %d", + 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) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "Checkpoint read object %d parent %d type %d chunk %d Parent type, %d, not directory", + 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(struct yaffs_obj *in, + struct yaffs_tnode *tn, u32 level, + int chunk_offset) +{ + int i; + struct yaffs_dev *dev = in->my_dev; + int ok = 1; + u32 base_offset; + + if (!tn) + return 1; + + if (level > 0) { + for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++) { + if (!tn->internal[i]) + continue; + ok = yaffs2_checkpt_tnode_worker(in, + tn->internal[i], + level - 1, + (chunk_offset << + YAFFS_TNODES_INTERNAL_BITS) + i); + } + return ok; + } + + /* Level 0 tnode */ + 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(struct yaffs_obj *obj) +{ + u32 end_marker = ~0; + int ok = 1; + + if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE) + return ok; + + 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(struct yaffs_obj *obj) +{ + u32 base_chunk; + int ok = 1; + struct yaffs_dev *dev = obj->my_dev; + struct yaffs_file_var *file_stuct_ptr = &obj->variant.file_variant; + struct yaffs_tnode *tn; + int nread = 0; + + ok = (yaffs2_checkpt_rd(dev, &base_chunk, sizeof(base_chunk)) == + sizeof(base_chunk)); + + 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)); + } + + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "Checkpoint read tnodes %d records, last %d. ok %d", + nread, base_chunk, ok); + + return ok ? 1 : 0; +} + +static int yaffs2_wr_checkpt_objs(struct yaffs_dev *dev) +{ + struct yaffs_obj *obj; + struct yaffs_checkpt_obj cp; + int i; + int ok = 1; + struct list_head *lh; + + /* Iterate through the objects in each hash entry, + * dumping them to the checkpointing stream. + */ + + for (i = 0; ok && i < YAFFS_NOBJECT_BUCKETS; i++) { + list_for_each(lh, &dev->obj_bucket[i].list) { + obj = list_entry(lh, struct yaffs_obj, hash_link); + if (!obj->defered_free) { + yaffs2_obj_checkpt_obj(&cp, obj); + cp.struct_type = sizeof(cp); + + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "Checkpoint write object %d parent %d type %d chunk %d obj addr %p", + 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(struct yaffs_checkpt_obj)); + 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(struct yaffs_dev *dev) +{ + struct yaffs_obj *obj; + struct yaffs_checkpt_obj cp; + int ok = 1; + int done = 0; + LIST_HEAD(hard_list); + + + while (ok && !done) { + ok = (yaffs2_checkpt_rd(dev, &cp, sizeof(cp)) == sizeof(cp)); + if (cp.struct_type != sizeof(cp)) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "struct size %d instead of %d ok %d", + cp.struct_type, (int)sizeof(cp), ok); + ok = 0; + } + + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "Checkpoint read object %d parent %d type %d chunk %d ", + 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 = yaffs2_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) { + list_add(&obj->hard_links, &hard_list); + } + } else { + ok = 0; + } + } + } + + if (ok) + yaffs_link_fixup(dev, &hard_list); + + return ok ? 1 : 0; +} + +static int yaffs2_wr_checkpt_sum(struct yaffs_dev *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(struct yaffs_dev *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(struct yaffs_dev *dev) +{ + int ok = 1; + + if (!yaffs2_checkpt_required(dev)) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "skipping checkpoint write"); + ok = 0; + } + + if (ok) + ok = yaffs2_checkpt_open(dev, 1); + + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "write checkpoint validity"); + ok = yaffs2_wr_checkpt_validity_marker(dev, 1); + } + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "write checkpoint device"); + ok = yaffs2_wr_checkpt_dev(dev); + } + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "write checkpoint objects"); + ok = yaffs2_wr_checkpt_objs(dev); + } + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "write checkpoint validity"); + 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(struct yaffs_dev *dev) +{ + int ok = 1; + + if (!dev->param.is_yaffs2) + ok = 0; + + if (ok && dev->param.skip_checkpt_rd) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "skipping checkpoint read"); + ok = 0; + } + + if (ok) + ok = yaffs2_checkpt_open(dev, 0); /* open for read */ + + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "read checkpoint validity"); + ok = yaffs2_rd_checkpt_validity_marker(dev, 1); + } + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "read checkpoint device"); + ok = yaffs2_rd_checkpt_dev(dev); + } + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "read checkpoint objects"); + ok = yaffs2_rd_checkpt_objs(dev); + } + if (ok) { + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "read checkpoint validity"); + ok = yaffs2_rd_checkpt_validity_marker(dev, 0); + } + + if (ok) { + ok = yaffs2_rd_checkpt_sum(dev); + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "read checkpoint checksum %d", 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(struct yaffs_dev *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(struct yaffs_dev *dev) +{ + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "save entry: is_checkpointed %d", + 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); + } + + yaffs_trace(YAFFS_TRACE_CHECKPOINT | YAFFS_TRACE_MOUNT, + "save exit: is_checkpointed %d", + dev->is_checkpointed); + + return dev->is_checkpointed; +} + +int yaffs2_checkpt_restore(struct yaffs_dev *dev) +{ + int retval; + + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "restore entry: is_checkpointed %d", + 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); + } + + yaffs_trace(YAFFS_TRACE_CHECKPOINT, + "restore exit: is_checkpointed %d", + dev->is_checkpointed); + + return retval; +} + +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size) +{ + /* if new_size > old_file_size. + * We're going to be writing a hole. + * If the hole is small then write zeros otherwise write a start + * of hole marker. + */ + loff_t old_file_size; + loff_t increase; + int small_hole; + int result = YAFFS_OK; + struct yaffs_dev *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); + + if (local_buffer) { + /* fill hole with zero bytes */ + loff_t 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); + + /* If 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; +} + +struct yaffs_block_index { + int seq; + int block; +}; + +static int yaffs2_ybicmp(const void *a, const void *b) +{ + int aseq = ((struct yaffs_block_index *)a)->seq; + int bseq = ((struct yaffs_block_index *)b)->seq; + int ablock = ((struct yaffs_block_index *)a)->block; + int bblock = ((struct yaffs_block_index *)b)->block; + + if (aseq == bseq) + return ablock - bblock; + + return aseq - bseq; +} + +static inline int yaffs2_scan_chunk(struct yaffs_dev *dev, + struct yaffs_block_info *bi, + int blk, int chunk_in_block, + int *found_chunks, + u8 *chunk_data, + struct list_head *hard_list, + int summary_available) +{ + struct yaffs_obj_hdr *oh; + struct yaffs_obj *in; + struct yaffs_obj *parent; + int equiv_id; + loff_t file_size; + int is_shrink; + int is_unlinked; + struct yaffs_ext_tags tags; + int result; + int alloc_failed = 0; + int chunk = blk * dev->param.chunks_per_block + chunk_in_block; + struct yaffs_file_var *file_var; + struct yaffs_hardlink_var *hl_var; + struct yaffs_symlink_var *sl_var; + + if (summary_available) { + result = yaffs_summary_fetch(dev, &tags, chunk_in_block); + tags.seq_number = bi->seq_number; + } + + if (!summary_available || tags.obj_id == 0) { + result = yaffs_rd_chunk_tags_nand(dev, chunk, NULL, &tags); + dev->tags_used++; + } else { + dev->summary_used++; + } + + /* 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 (chunk_in_block == 0) { + /* We're looking at the first chunk in + * the block so the block is unused */ + bi->block_state = YAFFS_BLOCK_STATE_EMPTY; + dev->n_erased_blocks++; + } else { + if (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCAN || + bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING) { + if (dev->seq_number == bi->seq_number) { + /* Allocating from this block*/ + yaffs_trace(YAFFS_TRACE_SCAN, + " Allocating from %d %d", + blk, chunk_in_block); + + bi->block_state = + YAFFS_BLOCK_STATE_ALLOCATING; + dev->alloc_block = blk; + dev->alloc_page = chunk_in_block; + dev->alloc_block_finder = blk; + } else { + /* This is a partially written block + * that is not the current + * allocation block. + */ + yaffs_trace(YAFFS_TRACE_SCAN, + "Partially written block %d detected. gc will fix this.", + blk); + } + } + } + + dev->n_free_chunks++; + + } else if (tags.ecc_result == + YAFFS_ECC_RESULT_UNFIXED) { + yaffs_trace(YAFFS_TRACE_SCAN, + " Unfixed ECC in chunk(%d:%d), chunk ignored", + blk, chunk_in_block); + dev->n_free_chunks++; + } else if (tags.obj_id > YAFFS_MAX_OBJECT_ID || + tags.chunk_id > YAFFS_MAX_CHUNK_ID || + tags.obj_id == YAFFS_OBJECTID_SUMMARY || + (tags.chunk_id > 0 && + tags.n_bytes > dev->data_bytes_per_chunk) || + tags.seq_number != bi->seq_number) { + yaffs_trace(YAFFS_TRACE_SCAN, + "Chunk (%d:%d) with bad tags:obj = %d, chunk_id = %d, n_bytes = %d, ignored", + blk, chunk_in_block, 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... */ + loff_t endpos; + loff_t chunk_base = (tags.chunk_id - 1) * + dev->data_bytes_per_chunk; + + *found_chunks = 1; + + yaffs_set_chunk_bit(dev, blk, chunk_in_block); + 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 && + 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, chunk_in_block); + 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 = (struct yaffs_obj_hdr *)chunk_data; + + if (dev->param.inband_tags) { + /* Fix up the header if they got + * corrupted by inband tags */ + oh->shadows_obj = + oh->inband_shadowed_obj_id; + oh->is_shrink = + oh->inband_is_shrink; + } + + 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! */ + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy: Could not make object for object %d at chunk %d during scan", + tags.obj_id, chunk); + return YAFFS_FAIL; + } + + 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) + )) { + loff_t this_size = (oh) ? + yaffs_oh_to_size(oh) : + tags.extra_file_size; + 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)) + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy: Bad object type, %d != %d, for object %d at chunk %d during scan", + 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; + yaffs_load_attribs(in, oh); + in->lazy_loaded = 0; + } 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; + yaffs_load_attribs(in, oh); + + 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 = yaffs_oh_to_size(oh); + 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_file_size; + 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; + INIT_LIST_HEAD(&parent-> + variant.dir_variant.children); + } else if (!parent || + parent->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) { + /* Hoosterman, another problem.... + * Trying to use a non-directory as a directory + */ + + yaffs_trace(YAFFS_TRACE_ERROR, + "yaffs tragedy: attempting to use non-directory as a directory in scan. Put in lost+found." + ); + 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 */ + 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: + file_var = &in->variant.file_variant; + if (file_var->scanned_size < file_size) { + /* This covers the case where the file + * size is greater than the data held. + * This will happen if the file is + * resized to be larger than its + * current data extents. + */ + file_var->file_size = file_size; + file_var->scanned_size = file_size; + } + + if (file_var->shrink_size > file_size) + file_var->shrink_size = file_size; + + break; + case YAFFS_OBJECT_TYPE_HARDLINK: + hl_var = &in->variant.hardlink_variant; + if (!is_unlinked) { + hl_var->equiv_id = equiv_id; + list_add(&in->hard_links, hard_list); + } + break; + case YAFFS_OBJECT_TYPE_DIRECTORY: + /* Do nothing */ + break; + case YAFFS_OBJECT_TYPE_SPECIAL: + /* Do nothing */ + break; + case YAFFS_OBJECT_TYPE_SYMLINK: + sl_var = &in->variant.symlink_variant; + if (oh) { + sl_var->alias = + yaffs_clone_str(oh->alias); + if (!sl_var->alias) + alloc_failed = 1; + } + break; + } + } + } + return alloc_failed ? YAFFS_FAIL : YAFFS_OK; +} + +int yaffs2_scan_backwards(struct yaffs_dev *dev) +{ + int blk; + int block_iter; + int start_iter; + int end_iter; + int n_to_scan = 0; + enum yaffs_block_state state; + int c; + int deleted; + LIST_HEAD(hard_list); + struct yaffs_block_info *bi; + u32 seq_number; + int n_blocks = dev->internal_end_block - dev->internal_start_block + 1; + u8 *chunk_data; + int found_chunks; + int alloc_failed = 0; + struct yaffs_block_index *block_index = NULL; + int alt_block_index = 0; + int summary_available; + + yaffs_trace(YAFFS_TRACE_SCAN, + "yaffs2_scan_backwards starts intstartblk %d intendblk %d...", + dev->internal_start_block, dev->internal_end_block); + + dev->seq_number = YAFFS_LOWEST_SEQUENCE_NUMBER; + + block_index = + kmalloc(n_blocks * sizeof(struct yaffs_block_index), GFP_NOFS); + + if (!block_index) { + block_index = + vmalloc(n_blocks * sizeof(struct yaffs_block_index)); + alt_block_index = 1; + } + + if (!block_index) { + yaffs_trace(YAFFS_TRACE_SCAN, + "yaffs2_scan_backwards() could not allocate block index!" + ); + return YAFFS_FAIL; + } + + dev->blocks_in_checkpt = 0; + + chunk_data = yaffs_get_temp_buffer(dev); + + /* Scan all the blocks to determine their state */ + bi = dev->block_info; + for (blk = dev->internal_start_block; blk <= dev->internal_end_block; + blk++) { + 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 = YAFFS_BLOCK_STATE_CHECKPOINT; + if (bi->seq_number == YAFFS_SEQUENCE_BAD_BLOCK) + bi->block_state = YAFFS_BLOCK_STATE_DEAD; + + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, + "Block scanning block %d state %d seq %d", + blk, bi->block_state, seq_number); + + if (bi->block_state == YAFFS_BLOCK_STATE_CHECKPOINT) { + dev->blocks_in_checkpt++; + + } else if (bi->block_state == YAFFS_BLOCK_STATE_DEAD) { + yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, + "block %d is bad", blk); + } else if (bi->block_state == YAFFS_BLOCK_STATE_EMPTY) { + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "Block empty "); + dev->n_erased_blocks++; + dev->n_free_chunks += dev->param.chunks_per_block; + } else if (bi->block_state == + YAFFS_BLOCK_STATE_NEEDS_SCAN) { + /* 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! */ + yaffs_trace(YAFFS_TRACE_SCAN, + "Block scanning block %d has bad sequence number %d", + blk, seq_number); + } + } + bi++; + } + + yaffs_trace(YAFFS_TRACE_SCAN, "%d blocks to be sorted...", n_to_scan); + + cond_resched(); + + /* Sort the blocks by sequence number */ + sort(block_index, n_to_scan, sizeof(struct yaffs_block_index), + yaffs2_ybicmp, NULL); + + cond_resched(); + + yaffs_trace(YAFFS_TRACE_SCAN, "...done"); + + /* Now scan the blocks looking at the data. */ + start_iter = 0; + end_iter = n_to_scan - 1; + yaffs_trace(YAFFS_TRACE_SCAN_DEBUG, "%d blocks to scan", 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. */ + cond_resched(); + + /* get the block to scan in the correct order */ + blk = block_index[block_iter].block; + bi = yaffs_get_block_info(dev, blk); + deleted = 0; + + summary_available = yaffs_summary_read(dev, dev->sum_tags, blk); + + /* For each chunk in each block that needs scanning.... */ + found_chunks = 0; + if (summary_available) + c = dev->chunks_per_summary - 1; + else + c = dev->param.chunks_per_block - 1; + + for (/* c is already initialised */; + !alloc_failed && c >= 0 && + (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCAN || + bi->block_state == YAFFS_BLOCK_STATE_ALLOCATING); + c--) { + /* Scan backwards... + * Read the tags and decide what to do + */ + if (yaffs2_scan_chunk(dev, bi, blk, c, + &found_chunks, chunk_data, + &hard_list, summary_available) == + YAFFS_FAIL) + alloc_failed = 1; + } + + if (bi->block_state == YAFFS_BLOCK_STATE_NEEDS_SCAN) { + /* If we got this far while scanning, then the block + * is fully allocated. */ + bi->block_state = YAFFS_BLOCK_STATE_FULL; + } + + /* 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) + vfree(block_index); + else + kfree(block_index); + + /* Ok, we've done all the scanning. + * Fix up the hard link chains. + * We 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); + + if (alloc_failed) + return YAFFS_FAIL; + + yaffs_trace(YAFFS_TRACE_SCAN, "yaffs2_scan_backwards ends"); + + return YAFFS_OK; +} diff --git a/fs/yaffs2/yaffs_yaffs2.h b/fs/yaffs2/yaffs_yaffs2.h new file mode 100644 index 0000000..2363bfd --- /dev/null +++ b/fs/yaffs2/yaffs_yaffs2.h @@ -0,0 +1,39 @@ +/* + * YAFFS: Yet another Flash File System . A NAND-flash specific file system. + * + * Copyright (C) 2002-2011 Aleph One Ltd. + * for Toby Churchill Ltd and Brightstar Engineering + * + * Created by Charles Manning <charles(a)aleph1.co.uk> + * + * 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(struct yaffs_dev *dev); +void yaffs2_find_oldest_dirty_seq(struct yaffs_dev *dev); +void yaffs2_clear_oldest_dirty_seq(struct yaffs_dev *dev, + struct yaffs_block_info *bi); +void yaffs2_update_oldest_dirty_seq(struct yaffs_dev *dev, unsigned block_no, + struct yaffs_block_info *bi); +int yaffs_block_ok_for_gc(struct yaffs_dev *dev, struct yaffs_block_info *bi); +u32 yaffs2_find_refresh_block(struct yaffs_dev *dev); +int yaffs2_checkpt_required(struct yaffs_dev *dev); +int yaffs_calc_checkpt_blocks_required(struct yaffs_dev *dev); + +void yaffs2_checkpt_invalidate(struct yaffs_dev *dev); +int yaffs2_checkpt_save(struct yaffs_dev *dev); +int yaffs2_checkpt_restore(struct yaffs_dev *dev); + +int yaffs2_handle_hole(struct yaffs_obj *obj, loff_t new_size); +int yaffs2_scan_backwards(struct yaffs_dev *dev); + +#endif diff --git a/fs/yaffs2/yaffscfg.c b/fs/yaffs2/yaffscfg.c deleted file mode 100644 index 01399ea..0000000 --- a/fs/yaffs2/yaffscfg.c +++ /dev/null @@ -1,420 +0,0 @@ -/* - * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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. - */ - -/* - * yaffscfg.c The configuration for the "direct" use of yaffs. - * - * This file is intended to be modified to your requirements. - * There is no need to redistribute this file. - */ - -/* XXX U-BOOT XXX */ -#include <common.h> - -#include <config.h> -#include "nand.h" -#include "yaffscfg.h" -#include "yaffsfs.h" -#include "yaffs_packedtags2.h" -#include "yaffs_mtdif.h" -#include "yaffs_mtdif2.h" -#if 0 -#include <errno.h> -#else -#include "malloc.h" -#endif - -unsigned yaffs_traceMask = 0x0; /* Disable logging */ -static int yaffs_errno = 0; - -void yaffsfs_SetError(int err) -{ - //Do whatever to set error - yaffs_errno = err; -} - -int yaffsfs_GetError(void) -{ - return yaffs_errno; -} - -void yaffsfs_Lock(void) -{ -} - -void yaffsfs_Unlock(void) -{ -} - -__u32 yaffsfs_CurrentTime(void) -{ - return 0; -} - -void *yaffs_malloc(size_t size) -{ - return malloc(size); -} - -void yaffs_free(void *ptr) -{ - free(ptr); -} - -void yaffsfs_LocalInitialisation(void) -{ - // Define locking semaphore. -} - -// Configuration for: -// /ram 2MB ramdisk -// /boot 2MB boot disk (flash) -// /flash 14MB flash disk (flash) -// NB Though /boot and /flash occupy the same physical device they -// are still disticnt "yaffs_Devices. You may think of these as "partitions" -// using non-overlapping areas in the same device. -// - -#include "yaffs_ramdisk.h" -#include "yaffs_flashif.h" - -static int isMounted = 0; -#define MOUNT_POINT "/flash" -extern nand_info_t nand_info[]; - -/* XXX U-BOOT XXX */ -#if 0 -static yaffs_Device ramDev; -static yaffs_Device bootDev; -static yaffs_Device flashDev; -#endif - -static yaffsfs_DeviceConfiguration yaffsfs_config[] = { -/* XXX U-BOOT XXX */ -#if 0 - { "/ram", &ramDev}, - { "/boot", &bootDev}, - { "/flash", &flashDev}, -#else - { MOUNT_POINT, 0}, -#endif - {(void *)0,(void *)0} -}; - - -int yaffs_StartUp(void) -{ - struct mtd_info *mtd = &nand_info[0]; - int yaffsVersion = 2; - int nBlocks; - - yaffs_Device *flashDev = calloc(1, sizeof(yaffs_Device)); - yaffsfs_config[0].dev = flashDev; - - /* store the mtd device for later use */ - flashDev->genericDevice = mtd; - - // Stuff to configure YAFFS - // Stuff to initialise anything special (eg lock semaphore). - yaffsfs_LocalInitialisation(); - - // Set up devices - -/* XXX U-BOOT XXX */ -#if 0 - // /ram - ramDev.nBytesPerChunk = 512; - ramDev.nChunksPerBlock = 32; - ramDev.nReservedBlocks = 2; // Set this smaller for RAM - ramDev.startBlock = 1; // Can't use block 0 - ramDev.endBlock = 127; // Last block in 2MB. - ramDev.useNANDECC = 1; - ramDev.nShortOpCaches = 0; // Disable caching on this device. - ramDev.genericDevice = (void *) 0; // Used to identify the device in fstat. - ramDev.writeChunkWithTagsToNAND = yramdisk_WriteChunkWithTagsToNAND; - ramDev.readChunkWithTagsFromNAND = yramdisk_ReadChunkWithTagsFromNAND; - ramDev.eraseBlockInNAND = yramdisk_EraseBlockInNAND; - ramDev.initialiseNAND = yramdisk_InitialiseNAND; - - // /boot - bootDev.nBytesPerChunk = 612; - bootDev.nChunksPerBlock = 32; - bootDev.nReservedBlocks = 5; - bootDev.startBlock = 1; // Can't use block 0 - bootDev.endBlock = 127; // Last block in 2MB. - bootDev.useNANDECC = 0; // use YAFFS's ECC - bootDev.nShortOpCaches = 10; // Use caches - bootDev.genericDevice = (void *) 1; // Used to identify the device in fstat. - bootDev.writeChunkToNAND = yflash_WriteChunkToNAND; - bootDev.readChunkFromNAND = yflash_ReadChunkFromNAND; - bootDev.eraseBlockInNAND = yflash_EraseBlockInNAND; - bootDev.initialiseNAND = yflash_InitialiseNAND; -#endif - - // /flash - flashDev->nReservedBlocks = 5; -// flashDev->nShortOpCaches = (options.no_cache) ? 0 : 10; - flashDev->nShortOpCaches = 10; // Use caches - flashDev->useNANDECC = 0; // do not use YAFFS's ECC - - if (yaffsVersion == 2) - { - flashDev->writeChunkWithTagsToNAND = nandmtd2_WriteChunkWithTagsToNAND; - flashDev->readChunkWithTagsFromNAND = nandmtd2_ReadChunkWithTagsFromNAND; - flashDev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad; - flashDev->queryNANDBlock = nandmtd2_QueryNANDBlock; - flashDev->spareBuffer = YMALLOC(mtd->oobsize); - flashDev->isYaffs2 = 1; -#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17)) - flashDev->nDataBytesPerChunk = mtd->writesize; - flashDev->nChunksPerBlock = mtd->erasesize / mtd->writesize; -#else - flashDev->nDataBytesPerChunk = mtd->oobblock; - flashDev->nChunksPerBlock = mtd->erasesize / mtd->oobblock; -#endif - nBlocks = mtd->size / mtd->erasesize; - - flashDev->nCheckpointReservedBlocks = 10; - flashDev->startBlock = 0; - flashDev->endBlock = nBlocks - 1; - } - else - { - flashDev->writeChunkToNAND = nandmtd_WriteChunkToNAND; - flashDev->readChunkFromNAND = nandmtd_ReadChunkFromNAND; - flashDev->isYaffs2 = 0; - nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK); - flashDev->startBlock = 320; - flashDev->endBlock = nBlocks - 1; - flashDev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK; - flashDev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK; - } - - /* ... and common functions */ - flashDev->eraseBlockInNAND = nandmtd_EraseBlockInNAND; - flashDev->initialiseNAND = nandmtd_InitialiseNAND; - - yaffs_initialise(yaffsfs_config); - - return 0; -} - - -void make_a_file(char *yaffsName,char bval,int sizeOfFile) -{ - int outh; - int i; - unsigned char buffer[100]; - - outh = yaffs_open(yaffsName, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); - if (outh < 0) - { - printf("Error opening file: %d\n", outh); - return; - } - - memset(buffer,bval,100); - - do{ - i = sizeOfFile; - if(i > 100) i = 100; - sizeOfFile -= i; - - yaffs_write(outh,buffer,i); - - } while (sizeOfFile > 0); - - - yaffs_close(outh); -} - -void read_a_file(char *fn) -{ - int h; - int i = 0; - unsigned char b; - - h = yaffs_open(fn, O_RDWR,0); - if(h<0) - { - printf("File not found\n"); - return; - } - - while(yaffs_read(h,&b,1)> 0) - { - printf("%02x ",b); - i++; - if(i > 32) - { - printf("\n"); - i = 0;; - } - } - printf("\n"); - yaffs_close(h); -} - -void cmd_yaffs_mount(char *mp) -{ - yaffs_StartUp(); - int retval = yaffs_mount(mp); - if( retval != -1) - isMounted = 1; - else - printf("Error mounting %s, return value: %d\n", mp, yaffsfs_GetError()); -} - -static void checkMount(void) -{ - if( !isMounted ) - { - cmd_yaffs_mount(MOUNT_POINT); - } -} - -void cmd_yaffs_umount(char *mp) -{ - checkMount(); - if( yaffs_unmount(mp) == -1) - printf("Error umounting %s, return value: %d\n", mp, yaffsfs_GetError()); -} - -void cmd_yaffs_write_file(char *yaffsName,char bval,int sizeOfFile) -{ - checkMount(); - make_a_file(yaffsName,bval,sizeOfFile); -} - - -void cmd_yaffs_read_file(char *fn) -{ - checkMount(); - read_a_file(fn); -} - - -void cmd_yaffs_mread_file(char *fn, char *addr) -{ - int h; - struct yaffs_stat s; - - checkMount(); - - yaffs_stat(fn,&s); - - printf ("Copy %s to 0x%p... ", fn, addr); - h = yaffs_open(fn, O_RDWR,0); - if(h<0) - { - printf("File not found\n"); - return; - } - - yaffs_read(h,addr,(int)s.st_size); - printf("\t[DONE]\n"); - - yaffs_close(h); -} - - -void cmd_yaffs_mwrite_file(char *fn, char *addr, int size) -{ - int outh; - - checkMount(); - outh = yaffs_open(fn, O_CREAT | O_RDWR | O_TRUNC, S_IREAD | S_IWRITE); - if (outh < 0) - { - printf("Error opening file: %d\n", outh); - } - - yaffs_write(outh,addr,size); - - yaffs_close(outh); -} - - -void cmd_yaffs_ls(const char *mountpt, int longlist) -{ - int i; - yaffs_DIR *d; - yaffs_dirent *de; - struct yaffs_stat stat; - char tempstr[255]; - - checkMount(); - d = yaffs_opendir(mountpt); - - if(!d) - { - printf("opendir failed\n"); - } - else - { - for(i = 0; (de = yaffs_readdir(d)) != NULL; i++) - { - if (longlist) - { - sprintf(tempstr, "%s/%s", mountpt, de->d_name); - yaffs_stat(tempstr, &stat); - printf("%-25s\t%7ld\n",de->d_name, stat.st_size); - } - else - { - printf("%s\n",de->d_name); - } - } - } -} - - -void cmd_yaffs_mkdir(const char *dir) -{ - checkMount(); - - int retval = yaffs_mkdir(dir, 0); - - if ( retval < 0) - printf("yaffs_mkdir returning error: %d\n", retval); -} - -void cmd_yaffs_rmdir(const char *dir) -{ - checkMount(); - - int retval = yaffs_rmdir(dir); - - if ( retval < 0) - printf("yaffs_rmdir returning error: %d\n", retval); -} - -void cmd_yaffs_rm(const char *path) -{ - checkMount(); - - int retval = yaffs_unlink(path); - - if ( retval < 0) - printf("yaffs_unlink returning error: %d\n", retval); -} - -void cmd_yaffs_mv(const char *oldPath, const char *newPath) -{ - checkMount(); - - int retval = yaffs_rename(newPath, oldPath); - - if ( retval < 0) - printf("yaffs_unlink returning error: %d\n", retval); -} diff --git a/fs/yaffs2/yaffscfg.h b/fs/yaffs2/yaffscfg.h index 3503dc8..1ffaae9 100644 --- a/fs/yaffs2/yaffscfg.h +++ b/fs/yaffs2/yaffscfg.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -23,23 +23,17 @@ #define __YAFFSCFG_H__ -#include "devextras.h" +#include "yportenv.h" -#define YAFFSFS_N_HANDLES 200 +#define YAFFSFS_N_HANDLES 100 +#define YAFFSFS_N_DSC 20 -typedef struct { - const char *prefix; - struct yaffs_DeviceStruct *dev; -} yaffsfs_DeviceConfiguration; +struct yaffsfs_DeviceConfiguration { + const YCHAR *prefix; + struct yaffs_dev *dev; +}; -void yaffsfs_Lock(void); -void yaffsfs_Unlock(void); - -__u32 yaffsfs_CurrentTime(void); - -void yaffsfs_SetError(int err); -int yaffsfs_GetError(void); - #endif + diff --git a/fs/yaffs2/yaffsfs.c b/fs/yaffs2/yaffsfs.c index 111cb34..9f1397b 100644 --- a/fs/yaffs2/yaffsfs.c +++ b/fs/yaffs2/yaffsfs.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -11,19 +11,13 @@ * published by the Free Software Foundation. */ -/* XXX U-BOOT XXX */ -#include <common.h> -#include <malloc.h> - #include "yaffsfs.h" #include "yaffs_guts.h" #include "yaffscfg.h" #include "yportenv.h" +#include "yaffs_trace.h" -/* XXX U-BOOT XXX */ -#if 0 -#include <string.h> // for memset -#endif +#include "string.h" #define YAFFSFS_MAX_SYMLINK_DEREFERENCES 5 @@ -31,452 +25,968 @@ #define NULL ((void *)0) #endif +/* YAFFSFS_RW_SIZE must be a power of 2 */ +#define YAFFSFS_RW_SHIFT (13) +#define YAFFSFS_RW_SIZE (1<<YAFFSFS_RW_SHIFT) -const char *yaffsfs_c_version="$Id: yaffsfs.c,v 1.18 2007/07/18 19:40:38 charles Exp $"; - -// configurationList is the list of devices that are supported -static yaffsfs_DeviceConfiguration *yaffsfs_configurationList; +/* Some forward references */ +static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relativeDirectory, + const YCHAR *path, + int symDepth, int getEquiv, + struct yaffs_obj **dirOut, + int *notDir, int *loop); +static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj); -/* Some forward references */ -static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const char *path, int symDepth); -static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj); +unsigned int yaffs_wr_attempts; +/* + * Handle management. + * There are open inodes in struct yaffsfs_Inode. + * There are open file descriptors in yaffsfs_FileDes. + * There are open handles in yaffsfs_FileDes. + * + * Things are structured this way to be like the Linux VFS model + * so that interactions with the yaffs guts calls are similar. + * That means more common code paths and less special code. + * That means better testing etc. + * + * We have 3 layers because: + * A handle is different than an fd because you can use dup() + * to create a new handle that accesses the *same* fd. The two + * handles will use the same offset (part of the fd). We only close + * down the fd when there are no more handles accessing it. + * + * More than one fd can currently access one file, but each fd + * has its own permsiions and offset. + */ -// Handle management. -// +struct yaffsfs_Inode { + int count; /* Number of handles accessing this inode */ + struct yaffs_obj *iObj; +}; + +struct yaffsfs_FileDes { + u8 reading:1; + u8 writing:1; + u8 append:1; + u8 shareRead:1; + u8 shareWrite:1; + int inodeId:12; /* Index to corresponding yaffsfs_Inode */ + int handleCount:10; /* Number of handles for this fd */ + loff_t position; /* current position in file */ +}; + +struct yaffsfs_Handle { + short int fdId; + short int useCount; +}; + + +struct yaffsfs_DirSearchContxt { + struct yaffs_dirent de; /* directory entry */ + YCHAR name[NAME_MAX + 1]; /* name of directory being searched */ + struct yaffs_obj *dirObj; /* ptr to directory being searched */ + struct yaffs_obj *nextReturn; /* obj returned by next readddir */ + struct list_head others; + int offset:20; + unsigned inUse:1; +}; +static struct yaffsfs_DirSearchContxt yaffsfs_dsc[YAFFSFS_N_DSC]; +static struct yaffsfs_Inode yaffsfs_inode[YAFFSFS_N_HANDLES]; +static struct yaffsfs_FileDes yaffsfs_fd[YAFFSFS_N_HANDLES]; +static struct yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES]; -unsigned int yaffs_wr_attempts; +static int yaffsfs_handlesInitialised; -typedef struct +unsigned yaffs_set_trace(unsigned tm) { - __u8 inUse:1; // this handle is in use - __u8 readOnly:1; // this handle is read only - __u8 append:1; // append only - __u8 exclusive:1; // exclusive - __u32 position; // current position in file - yaffs_Object *obj; // the object -}yaffsfs_Handle; + yaffs_trace_mask = tm; + return yaffs_trace_mask; +} +unsigned yaffs_get_trace(void) +{ + return yaffs_trace_mask; +} -static yaffsfs_Handle yaffsfs_handle[YAFFSFS_N_HANDLES]; +/* + * yaffsfs_InitHandle + * Inilitalise handle management on start-up. + */ -// yaffsfs_InitHandle -/// Inilitalise handles on start-up. -// -static int yaffsfs_InitHandles(void) +static void yaffsfs_InitHandles(void) { int i; - for(i = 0; i < YAFFSFS_N_HANDLES; i++) - { - yaffsfs_handle[i].inUse = 0; - yaffsfs_handle[i].obj = NULL; - } - return 0; + if (yaffsfs_handlesInitialised) + return; + + memset(yaffsfs_inode, 0, sizeof(yaffsfs_inode)); + memset(yaffsfs_fd, 0, sizeof(yaffsfs_fd)); + memset(yaffsfs_handle, 0, sizeof(yaffsfs_handle)); + memset(yaffsfs_dsc, 0, sizeof(yaffsfs_dsc)); + + for (i = 0; i < YAFFSFS_N_HANDLES; i++) + yaffsfs_fd[i].inodeId = -1; + for (i = 0; i < YAFFSFS_N_HANDLES; i++) + yaffsfs_handle[i].fdId = -1; } -yaffsfs_Handle *yaffsfs_GetHandlePointer(int h) +static struct yaffsfs_Handle *yaffsfs_HandleToPointer(int h) { - if(h < 0 || h >= YAFFSFS_N_HANDLES) - { - return NULL; - } + if (h >= 0 && h < YAFFSFS_N_HANDLES) + return &yaffsfs_handle[h]; + return NULL; +} + +static struct yaffsfs_FileDes *yaffsfs_HandleToFileDes(int handle) +{ + struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle); + + if (h && h->useCount > 0 && h->fdId >= 0 && h->fdId < YAFFSFS_N_HANDLES) + return &yaffsfs_fd[h->fdId]; - return &yaffsfs_handle[h]; + return NULL; } -yaffs_Object *yaffsfs_GetHandleObject(int handle) +static struct yaffsfs_Inode *yaffsfs_HandleToInode(int handle) { - yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle); + struct yaffsfs_FileDes *fd = yaffsfs_HandleToFileDes(handle); - if(h && h->inUse) - { - return h->obj; - } + if (fd && fd->handleCount > 0 && + fd->inodeId >= 0 && fd->inodeId < YAFFSFS_N_HANDLES) + return &yaffsfs_inode[fd->inodeId]; return NULL; } +static struct yaffs_obj *yaffsfs_HandleToObject(int handle) +{ + struct yaffsfs_Inode *in = yaffsfs_HandleToInode(handle); + + if (in) + return in->iObj; + + return NULL; +} + +/* + * yaffsfs_FindInodeIdForObject + * Find the inode entry for an object, if it exists. + */ -//yaffsfs_GetHandle -// Grab a handle (when opening a file) -// +static int yaffsfs_FindInodeIdForObject(struct yaffs_obj *obj) +{ + int i; + int ret = -1; + + if (obj) + obj = yaffs_get_equivalent_obj(obj); + + /* Look for it in open inode table */ + for (i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++) { + if (yaffsfs_inode[i].iObj == obj) + ret = i; + } + return ret; +} -static int yaffsfs_GetHandle(void) +/* + * yaffsfs_GetInodeIdForObject + * Grab an inode entry when opening a new inode. + */ +static int yaffsfs_GetInodeIdForObject(struct yaffs_obj *obj) { int i; - yaffsfs_Handle *h; - - for(i = 0; i < YAFFSFS_N_HANDLES; i++) - { - h = yaffsfs_GetHandlePointer(i); - if(!h) - { - // todo bug: should never happen + int ret; + struct yaffsfs_Inode *in = NULL; + + if (obj) + obj = yaffs_get_equivalent_obj(obj); + + ret = yaffsfs_FindInodeIdForObject(obj); + + for (i = 0; i < YAFFSFS_N_HANDLES && ret < 0; i++) { + if (!yaffsfs_inode[i].iObj) + ret = i; + } + + if (ret >= 0) { + in = &yaffsfs_inode[ret]; + if (!in->iObj) + in->count = 0; + in->iObj = obj; + in->count++; + } + + return ret; +} + +static int yaffsfs_CountHandles(struct yaffs_obj *obj) +{ + int i = yaffsfs_FindInodeIdForObject(obj); + + if (i >= 0) + return yaffsfs_inode[i].count; + else + return 0; +} + +static void yaffsfs_ReleaseInode(struct yaffsfs_Inode *in) +{ + struct yaffs_obj *obj; + + obj = in->iObj; + + if (obj->unlinked) + yaffs_del_obj(obj); + + obj->my_inode = NULL; + in->iObj = NULL; + +} + +static void yaffsfs_PutInode(int inodeId) +{ + if (inodeId >= 0 && inodeId < YAFFSFS_N_HANDLES) { + struct yaffsfs_Inode *in = &yaffsfs_inode[inodeId]; + in->count--; + if (in->count <= 0) { + yaffsfs_ReleaseInode(in); + in->count = 0; } - if(!h->inUse) - { - memset(h,0,sizeof(yaffsfs_Handle)); - h->inUse=1; + } +} + +static int yaffsfs_NewHandle(struct yaffsfs_Handle **hptr) +{ + int i; + struct yaffsfs_Handle *h; + + for (i = 0; i < YAFFSFS_N_HANDLES; i++) { + h = &yaffsfs_handle[i]; + if (h->useCount < 1) { + memset(h, 0, sizeof(struct yaffsfs_Handle)); + h->fdId = -1; + h->useCount = 1; + if (hptr) + *hptr = h; return i; } } return -1; } -// yaffs_PutHandle -// Let go of a handle (when closing a file) -// -static int yaffsfs_PutHandle(int handle) +static int yaffsfs_NewHandleAndFileDes(void) { - yaffsfs_Handle *h = yaffsfs_GetHandlePointer(handle); + int i; + struct yaffsfs_FileDes *fd; + struct yaffsfs_Handle *h = NULL; + int handle = yaffsfs_NewHandle(&h); + + if (handle < 0) + return -1; + + for (i = 0; i < YAFFSFS_N_HANDLES; i++) { + fd = &yaffsfs_fd[i]; + if (fd->handleCount < 1) { + memset(fd, 0, sizeof(struct yaffsfs_FileDes)); + fd->inodeId = -1; + fd->handleCount = 1; + h->fdId = i; + return handle; + } + } + + /* Dump the handle because we could not get a fd */ + h->useCount = 0; + return -1; +} + +/* + * yaffs_get_handle + * Increase use of handle when reading/writing a file + * Also gets the file descriptor. + */ + +static int yaffsfs_GetHandle(int handle) +{ + struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle); + + if (h && h->useCount > 0) { + h->useCount++; + return 0; + } + return -1; +} + +/* + * yaffs_put_handle + * Let go of a handle when closing a file or aborting an open or + * ending a read or write. + */ - if(h) - { - h->inUse = 0; - h->obj = NULL; +static int yaffsfs_PutFileDes(int fdId) +{ + struct yaffsfs_FileDes *fd; + + if (fdId >= 0 && fdId < YAFFSFS_N_HANDLES) { + fd = &yaffsfs_fd[fdId]; + fd->handleCount--; + if (fd->handleCount < 1) { + if (fd->inodeId >= 0) { + yaffsfs_PutInode(fd->inodeId); + fd->inodeId = -1; + } + } } return 0; } +static int yaffsfs_PutHandle(int handle) +{ + struct yaffsfs_Handle *h = yaffsfs_HandleToPointer(handle); + if (h && h->useCount > 0) { + h->useCount--; + if (h->useCount < 1) { + yaffsfs_PutFileDes(h->fdId); + h->fdId = -1; + } + } -// Stuff to search for a directory from a path + return 0; +} +static void yaffsfs_BreakDeviceHandles(struct yaffs_dev *dev) +{ + struct yaffsfs_FileDes *fd; + struct yaffsfs_Handle *h; + struct yaffs_obj *obj; + int i; + for (i = 0; i < YAFFSFS_N_HANDLES; i++) { + h = yaffsfs_HandleToPointer(i); + fd = yaffsfs_HandleToFileDes(i); + obj = yaffsfs_HandleToObject(i); + if (h && h->useCount > 0) { + h->useCount = 0; + h->fdId = 0; + } + if (fd && fd->handleCount > 0 && obj && obj->my_dev == dev) { + fd->handleCount = 0; + yaffsfs_PutInode(fd->inodeId); + fd->inodeId = -1; + } + } +} -int yaffsfs_Match(char a, char b) +/* + * Stuff to handle names. + */ +#ifdef CONFIG_YAFFS_CASE_INSENSITIVE + +static int yaffs_toupper(YCHAR a) +{ + if (a >= 'a' && a <= 'z') + return (a - 'a') + 'A'; + else + return a; +} + +int yaffsfs_Match(YCHAR a, YCHAR b) +{ + return (yaffs_toupper(a) == yaffs_toupper(b)); +} +#else +int yaffsfs_Match(YCHAR a, YCHAR b) { - // case sensitive + /* case sensitive */ return (a == b); } +#endif + +int yaffsfs_IsPathDivider(YCHAR ch) +{ + const YCHAR *str = YAFFS_PATH_DIVIDERS; + + while (*str) { + if (*str == ch) + return 1; + str++; + } + + return 0; +} + +int yaffsfs_CheckNameLength(const char *name) +{ + int retVal = 0; + + int nameLength = yaffs_strnlen(name, YAFFS_MAX_NAME_LENGTH + 1); + + if (nameLength == 0) { + yaffsfs_SetError(-ENOENT); + retVal = -1; + } else if (nameLength > YAFFS_MAX_NAME_LENGTH) { + yaffsfs_SetError(-ENAMETOOLONG); + retVal = -1; + } + + return retVal; +} + +static int yaffsfs_alt_dir_path(const YCHAR *path, YCHAR **ret_path) +{ + YCHAR *alt_path = NULL; + int path_length; + int i; + + /* + * We don't have a definition for max path length. + * We will use 3 * max name length instead. + */ + *ret_path = NULL; + path_length = yaffs_strnlen(path, (YAFFS_MAX_NAME_LENGTH + 1) * 3 + 1); + + /* If the last character is a path divider, then we need to + * trim it back so that the name look-up works properly. + * eg. /foo/new_dir/ -> /foo/newdir + * Curveball: Need to handle multiple path dividers: + * eg. /foof/sdfse///// -> /foo/sdfse + */ + if (path_length > 0 && yaffsfs_IsPathDivider(path[path_length - 1])) { + alt_path = kmalloc(path_length + 1, 0); + if (!alt_path) + return -1; + yaffs_strcpy(alt_path, path); + for (i = path_length - 1; + i >= 0 && yaffsfs_IsPathDivider(alt_path[i]); i--) + alt_path[i] = (YCHAR) 0; + } + *ret_path = alt_path; + return 0; +} + +LIST_HEAD(yaffsfs_deviceList); -// yaffsfs_FindDevice -// yaffsfs_FindRoot -// Scan the configuration list to find the root. -// Curveballs: Should match paths that end in '/' too -// Curveball2 Might have "/x/ and "/x/y". Need to return the longest match -static yaffs_Device *yaffsfs_FindDevice(const char *path, char **restOfPath) +/* + * yaffsfs_FindDevice + * yaffsfs_FindRoot + * Scan the configuration list to find the device + * Curveballs: Should match paths that end in '/' too + * Curveball2 Might have "/x/ and "/x/y". Need to return the longest match + */ +static struct yaffs_dev *yaffsfs_FindDevice(const YCHAR *path, + YCHAR **restOfPath) { - yaffsfs_DeviceConfiguration *cfg = yaffsfs_configurationList; - const char *leftOver; - const char *p; - yaffs_Device *retval = NULL; + struct list_head *cfg; + const YCHAR *leftOver; + const YCHAR *p; + struct yaffs_dev *retval = NULL; + struct yaffs_dev *dev = NULL; int thisMatchLength; int longestMatch = -1; + int matching; - // Check all configs, choose the one that: - // 1) Actually matches a prefix (ie /a amd /abc will not match - // 2) Matches the longest. - while(cfg && cfg->prefix && cfg->dev) - { + /* + * Check all configs, choose the one that: + * 1) Actually matches a prefix (ie /a amd /abc will not match + * 2) Matches the longest. + */ + list_for_each(cfg, &yaffsfs_deviceList) { + dev = list_entry(cfg, struct yaffs_dev, dev_list); leftOver = path; - p = cfg->prefix; + p = dev->param.name; thisMatchLength = 0; + matching = 1; + + while (matching && *p && *leftOver) { + /* Skip over any /s */ + while (yaffsfs_IsPathDivider(*p)) + p++; + + /* Skip over any /s */ + while (yaffsfs_IsPathDivider(*leftOver)) + leftOver++; + + /* Now match the text part */ + while (matching && + *p && !yaffsfs_IsPathDivider(*p) && + *leftOver && !yaffsfs_IsPathDivider(*leftOver)) { + if (yaffsfs_Match(*p, *leftOver)) { + p++; + leftOver++; + thisMatchLength++; + } else { + matching = 0; + } + } + } - while(*p && //unmatched part of prefix - strcmp(p,"/") && // the rest of the prefix is not / (to catch / at end) - *leftOver && - yaffsfs_Match(*p,*leftOver)) - { - p++; + /* Skip over any /s in leftOver */ + while (yaffsfs_IsPathDivider(*leftOver)) leftOver++; - thisMatchLength++; - } - if((!*p || strcmp(p,"/") == 0) && // end of prefix - (!*leftOver || *leftOver == '/') && // no more in this path name part - (thisMatchLength > longestMatch)) - { - // Matched prefix - *restOfPath = (char *)leftOver; - retval = cfg->dev; + + /*Skip over any /s in p */ + while (yaffsfs_IsPathDivider(*p)) + p++; + + /* p should now be at the end of the string if fully matched */ + if (*p) + matching = 0; + + if (matching && (thisMatchLength > longestMatch)) { + /* Matched prefix */ + *restOfPath = (YCHAR *) leftOver; + retval = dev; longestMatch = thisMatchLength; } - cfg++; + } return retval; } -static yaffs_Object *yaffsfs_FindRoot(const char *path, char **restOfPath) +static int yaffsfs_CheckPath(const YCHAR *path) { + int n = 0; + int divs = 0; - yaffs_Device *dev; - - dev= yaffsfs_FindDevice(path,restOfPath); - if(dev && dev->isMounted) - { - return dev->rootDir; + while (*path && n < YAFFS_MAX_NAME_LENGTH && divs < 100) { + if (yaffsfs_IsPathDivider(*path)) { + n = 0; + divs++; + } else + n++; + path++; } + + return (*path) ? -1 : 0; +} + +/* FindMountPoint only returns a dev entry if the path is a mount point */ +static struct yaffs_dev *yaffsfs_FindMountPoint(const YCHAR *path) +{ + struct yaffs_dev *dev; + YCHAR *restOfPath = NULL; + + dev = yaffsfs_FindDevice(path, &restOfPath); + if (dev && restOfPath && *restOfPath) + dev = NULL; + return dev; +} + +static struct yaffs_obj *yaffsfs_FindRoot(const YCHAR *path, + YCHAR **restOfPath) +{ + struct yaffs_dev *dev; + + dev = yaffsfs_FindDevice(path, restOfPath); + if (dev && dev->is_mounted) + return dev->root_dir; + return NULL; } -static yaffs_Object *yaffsfs_FollowLink(yaffs_Object *obj,int symDepth) +static struct yaffs_obj *yaffsfs_FollowLink(struct yaffs_obj *obj, + int symDepth, int *loop) { - while(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) - { - char *alias = obj->variant.symLinkVariant.alias; + if (obj) + obj = yaffs_get_equivalent_obj(obj); - if(*alias == '/') - { - // Starts with a /, need to scan from root up - obj = yaffsfs_FindObject(NULL,alias,symDepth++); - } + while (obj && obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) { + YCHAR *alias = obj->variant.symlink_variant.alias; + + if (yaffsfs_IsPathDivider(*alias)) + /* Starts with a /, need to scan from root up */ + obj = yaffsfs_FindObject(NULL, alias, symDepth++, + 1, NULL, NULL, loop); else - { - // Relative to here, so use the parent of the symlink as a start - obj = yaffsfs_FindObject(obj->parent,alias,symDepth++); - } + /* + * Relative to here so use the parent of the + * symlink as a start + */ + obj = yaffsfs_FindObject(obj->parent, alias, symDepth++, + 1, NULL, NULL, loop); } return obj; } - -// yaffsfs_FindDirectory -// Parse a path to determine the directory and the name within the directory. -// -// eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx" -static yaffs_Object *yaffsfs_DoFindDirectory(yaffs_Object *startDir,const char *path,char **name,int symDepth) +/* + * yaffsfs_FindDirectory + * Parse a path to determine the directory and the name within the directory. + * + * eg. "/data/xx/ff" --> puts name="ff" and returns the directory "/data/xx" + */ +static struct yaffs_obj *yaffsfs_DoFindDirectory(struct yaffs_obj *startDir, + const YCHAR *path, + YCHAR **name, int symDepth, + int *notDir, int *loop) { - yaffs_Object *dir; - char *restOfPath; - char str[YAFFS_MAX_NAME_LENGTH+1]; + struct yaffs_obj *dir; + YCHAR *restOfPath; + YCHAR str[YAFFS_MAX_NAME_LENGTH + 1]; int i; - if(symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES) - { + if (symDepth > YAFFSFS_MAX_SYMLINK_DEREFERENCES) { + if (loop) + *loop = 1; return NULL; } - if(startDir) - { + if (startDir) { dir = startDir; - restOfPath = (char *)path; - } - else - { - dir = yaffsfs_FindRoot(path,&restOfPath); - } - - while(dir) - { - // parse off /. - // curve ball: also throw away surplus '/' - // eg. "/ram/x////ff" gets treated the same as "/ram/x/ff" - while(*restOfPath == '/') - { - restOfPath++; // get rid of '/' - } + restOfPath = (YCHAR *) path; + } else + dir = yaffsfs_FindRoot(path, &restOfPath); + + while (dir) { + /* + * parse off /. + * curve ball: also throw away surplus '/' + * eg. "/ram/x////ff" gets treated the same as "/ram/x/ff" + */ + while (yaffsfs_IsPathDivider(*restOfPath)) + restOfPath++; /* get rid of '/' */ *name = restOfPath; i = 0; - while(*restOfPath && *restOfPath != '/') - { - if (i < YAFFS_MAX_NAME_LENGTH) - { + while (*restOfPath && !yaffsfs_IsPathDivider(*restOfPath)) { + if (i < YAFFS_MAX_NAME_LENGTH) { str[i] = *restOfPath; - str[i+1] = '\0'; + str[i + 1] = '\0'; i++; } restOfPath++; } - if(!*restOfPath) - { - // got to the end of the string + if (!*restOfPath) + /* got to the end of the string */ return dir; - } - else - { - if(strcmp(str,".") == 0) - { - // Do nothing - } - else if(strcmp(str,"..") == 0) - { + else { + if (yaffs_strcmp(str, _Y(".")) == 0) { + /* Do nothing */ + } else if (yaffs_strcmp(str, _Y("..")) == 0) { dir = dir->parent; - } - else - { - dir = yaffs_FindObjectByName(dir,str); - - while(dir && dir->variantType == YAFFS_OBJECT_TYPE_SYMLINK) - { + } else { + dir = yaffs_find_by_name(dir, str); - dir = yaffsfs_FollowLink(dir,symDepth); + dir = yaffsfs_FollowLink(dir, symDepth, loop); - } - - if(dir && dir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) - { + if (dir && dir->variant_type != + YAFFS_OBJECT_TYPE_DIRECTORY) { + if (notDir) + *notDir = 1; dir = NULL; } + } } } - // directory did not exist. + /* directory did not exist. */ return NULL; } -static yaffs_Object *yaffsfs_FindDirectory(yaffs_Object *relativeDirectory,const char *path,char **name,int symDepth) +static struct yaffs_obj *yaffsfs_FindDirectory(struct yaffs_obj *relDir, + const YCHAR *path, + YCHAR **name, + int symDepth, + int *notDir, int *loop) { - return yaffsfs_DoFindDirectory(relativeDirectory,path,name,symDepth); + return yaffsfs_DoFindDirectory(relDir, path, name, symDepth, notDir, + loop); } -// yaffsfs_FindObject turns a path for an existing object into the object -// -static yaffs_Object *yaffsfs_FindObject(yaffs_Object *relativeDirectory, const char *path,int symDepth) +/* + * yaffsfs_FindObject turns a path for an existing object into the object + */ +static struct yaffs_obj *yaffsfs_FindObject(struct yaffs_obj *relDir, + const YCHAR *path, int symDepth, + int getEquiv, + struct yaffs_obj **dirOut, + int *notDir, int *loop) { - yaffs_Object *dir; - char *name; + struct yaffs_obj *dir; + struct yaffs_obj *obj; + YCHAR *name; + + dir = + yaffsfs_FindDirectory(relDir, path, &name, symDepth, notDir, loop); + + if (dirOut) + *dirOut = dir; + + if (dir && *name) + obj = yaffs_find_by_name(dir, name); + else + obj = dir; + + if (getEquiv) + obj = yaffs_get_equivalent_obj(obj); + + return obj; +} + +/************************************************************************* + * Start of yaffsfs visible functions. + *************************************************************************/ - dir = yaffsfs_FindDirectory(relativeDirectory,path,&name,symDepth); +int yaffs_dup(int handle) +{ + int newHandleNumber = -1; + struct yaffsfs_FileDes *existingFD = NULL; + struct yaffsfs_Handle *existingHandle = NULL; + struct yaffsfs_Handle *newHandle = NULL; - if(dir && *name) - { - return yaffs_FindObjectByName(dir,name); + yaffsfs_Lock(); + existingHandle = yaffsfs_HandleToPointer(handle); + existingFD = yaffsfs_HandleToFileDes(handle); + if (existingFD) + newHandleNumber = yaffsfs_NewHandle(&newHandle); + if (newHandle) { + newHandle->fdId = existingHandle->fdId; + existingFD->handleCount++; } - return dir; + yaffsfs_Unlock(); + + if (!existingFD) + yaffsfs_SetError(-EBADF); + else if (!newHandle) + yaffsfs_SetError(-ENOMEM); + + return newHandleNumber; + } +static int yaffsfs_TooManyObjects(struct yaffs_dev *dev) +{ + int current_objects = dev->n_obj - dev->n_deleted_files; + if (dev->param.max_objects && current_objects > dev->param.max_objects) + return 1; + else + return 0; +} -int yaffs_open(const char *path, int oflag, int mode) +int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int sharing) { - yaffs_Object *obj = NULL; - yaffs_Object *dir = NULL; - char *name; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + YCHAR *name; int handle = -1; - yaffsfs_Handle *h = NULL; - int alreadyOpen = 0; - int alreadyExclusive = 0; + struct yaffsfs_FileDes *fd = NULL; int openDenied = 0; int symDepth = 0; int errorReported = 0; + int rwflags = oflag & (O_RDWR | O_RDONLY | O_WRONLY); + u8 shareRead = (sharing & YAFFS_SHARE_READ) ? 1 : 0; + u8 shareWrite = (sharing & YAFFS_SHARE_WRITE) ? 1 : 0; + u8 sharedReadAllowed; + u8 sharedWriteAllowed; + u8 alreadyReading; + u8 alreadyWriting; + u8 readRequested; + u8 writeRequested; + int notDir = 0; + int loop = 0; - int i; + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + /* O_EXCL only has meaning if O_CREAT is specified */ + if (!(oflag & O_CREAT)) + oflag &= ~(O_EXCL); + + /* O_TRUNC has no meaning if (O_CREAT | O_EXCL) is specified */ + if ((oflag & O_CREAT) & (oflag & O_EXCL)) + oflag &= ~(O_TRUNC); + /* Todo: Are there any more flag combos to sanitise ? */ - // todo sanity check oflag (eg. can't have O_TRUNC without WRONLY or RDWR + /* Figure out if reading or writing is requested */ + readRequested = (rwflags == O_RDWR || rwflags == O_RDONLY) ? 1 : 0; + writeRequested = (rwflags == O_RDWR || rwflags == O_WRONLY) ? 1 : 0; yaffsfs_Lock(); - handle = yaffsfs_GetHandle(); + handle = yaffsfs_NewHandleAndFileDes(); - if(handle >= 0) - { + if (handle < 0) { + yaffsfs_SetError(-ENFILE); + errorReported = 1; + } else { - h = yaffsfs_GetHandlePointer(handle); + fd = yaffsfs_HandleToFileDes(handle); + /* try to find the exisiting object */ + obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL); - // try to find the exisiting object - obj = yaffsfs_FindObject(NULL,path,0); + obj = yaffsfs_FollowLink(obj, symDepth++, &loop); - if(obj && obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) - { + if (obj && + obj->variant_type != YAFFS_OBJECT_TYPE_FILE && + obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + obj = NULL; - obj = yaffsfs_FollowLink(obj,symDepth++); - } + if (obj) { - if(obj) - { - // Check if the object is already in use - alreadyOpen = alreadyExclusive = 0; - - for(i = 0; i <= YAFFSFS_N_HANDLES; i++) - { - - if(i != handle && - yaffsfs_handle[i].inUse && - obj == yaffsfs_handle[i].obj) - { - alreadyOpen = 1; - if(yaffsfs_handle[i].exclusive) - { - alreadyExclusive = 1; - } - } - } + /* The file already exists or it might be a directory */ - if(((oflag & O_EXCL) && alreadyOpen) || alreadyExclusive) - { + /* A directory can't be opened as a file */ + if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { openDenied = 1; + yaffsfs_SetError(-EISDIR); + errorReported = 1; } - // Open should fail if O_CREAT and O_EXCL are specified - if((oflag & O_EXCL) && (oflag & O_CREAT)) - { + /* Open should fail if O_CREAT and O_EXCL are specified + * for a file that exists. + */ + if (!errorReported && + (oflag & O_EXCL) && (oflag & O_CREAT)) { openDenied = 1; yaffsfs_SetError(-EEXIST); errorReported = 1; } - // Check file permissions - if( (oflag & (O_RDWR | O_WRONLY)) == 0 && // ie O_RDONLY - !(obj->yst_mode & S_IREAD)) - { + /* Check file permissions */ + if (readRequested && !(obj->yst_mode & S_IREAD)) openDenied = 1; - } - if( (oflag & O_RDWR) && - !(obj->yst_mode & S_IREAD)) - { + if (writeRequested && !(obj->yst_mode & S_IWRITE)) openDenied = 1; - } - if( (oflag & (O_RDWR | O_WRONLY)) && - !(obj->yst_mode & S_IWRITE)) - { + if (!errorReported && writeRequested && + obj->my_dev->read_only) { openDenied = 1; + yaffsfs_SetError(-EROFS); + errorReported = 1; } - } + if (openDenied && !errorReported) { + yaffsfs_SetError(-EACCES); + errorReported = 1; + } + + /* Check sharing of an existing object. */ + if (!openDenied) { + struct yaffsfs_FileDes *fdx; + int i; + + sharedReadAllowed = 1; + sharedWriteAllowed = 1; + alreadyReading = 0; + alreadyWriting = 0; + for (i = 0; i < YAFFSFS_N_HANDLES; i++) { + fdx = &yaffsfs_fd[i]; + if (fdx->handleCount > 0 && + fdx->inodeId >= 0 && + yaffsfs_inode[fdx->inodeId].iObj + == obj) { + if (!fdx->shareRead) + sharedReadAllowed = 0; + if (!fdx->shareWrite) + sharedWriteAllowed = 0; + if (fdx->reading) + alreadyReading = 1; + if (fdx->writing) + alreadyWriting = 1; + } + } - else if((oflag & O_CREAT)) - { - // Let's see if we can create this file - dir = yaffsfs_FindDirectory(NULL,path,&name,0); - if(dir) - { - obj = yaffs_MknodFile(dir,name,mode,0,0); + if ((!sharedReadAllowed && readRequested) || + (!shareRead && alreadyReading) || + (!sharedWriteAllowed && writeRequested) || + (!shareWrite && alreadyWriting)) { + openDenied = 1; + yaffsfs_SetError(-EBUSY); + errorReported = 1; + } } - else - { + + } + + /* If we could not open an existing object, then let's see if + * the directory exists. If not, error. + */ + if (!obj && !errorReported) { + dir = yaffsfs_FindDirectory(NULL, path, &name, 0, + &notDir, &loop); + if (!dir && notDir) { yaffsfs_SetError(-ENOTDIR); + errorReported = 1; + } else if (loop) { + yaffsfs_SetError(-ELOOP); + errorReported = 1; + } else if (!dir) { + yaffsfs_SetError(-ENOENT); + errorReported = 1; } } - if(obj && !openDenied) - { - h->obj = obj; - h->inUse = 1; - h->readOnly = (oflag & (O_WRONLY | O_RDWR)) ? 0 : 1; - h->append = (oflag & O_APPEND) ? 1 : 0; - h->exclusive = (oflag & O_EXCL) ? 1 : 0; - h->position = 0; - - obj->inUse++; - if((oflag & O_TRUNC) && !h->readOnly) - { - //todo truncate - yaffs_ResizeFile(obj,0); + if (!obj && dir && !errorReported && (oflag & O_CREAT)) { + /* Let's see if we can create this file */ + if (dir->my_dev->read_only) { + yaffsfs_SetError(-EROFS); + errorReported = 1; + } else if (yaffsfs_TooManyObjects(dir->my_dev)) { + yaffsfs_SetError(-ENFILE); + errorReported = 1; + } else + obj = yaffs_create_file(dir, name, mode, 0, 0); + + if (!obj && !errorReported) { + yaffsfs_SetError(-ENOSPC); + errorReported = 1; } + } + if (!obj && dir && !errorReported && !(oflag & O_CREAT)) { + yaffsfs_SetError(-ENOENT); + errorReported = 1; } - else - { - yaffsfs_PutHandle(handle); - if(!errorReported) - { - yaffsfs_SetError(-EACCESS); - errorReported = 1; + + if (obj && !openDenied) { + int inodeId = yaffsfs_GetInodeIdForObject(obj); + + if (inodeId < 0) { + /* + * Todo: Fix any problem if inodes run out, + * That can't happen if the number of inode + * items >= number of handles. + */ } + + fd->inodeId = inodeId; + fd->reading = readRequested; + fd->writing = writeRequested; + fd->append = (oflag & O_APPEND) ? 1 : 0; + fd->position = 0; + fd->shareRead = shareRead; + fd->shareWrite = shareWrite; + + /* Hook inode to object */ + obj->my_inode = (void *)&yaffsfs_inode[inodeId]; + + if ((oflag & O_TRUNC) && fd->writing) + yaffs_resize_file(obj, 0); + } else { + yaffsfs_PutHandle(handle); + if (!errorReported) + yaffsfs_SetError(0); /* Problem */ handle = -1; } - } yaffsfs_Unlock(); @@ -484,32 +994,68 @@ int yaffs_open(const char *path, int oflag, int mode) return handle; } -int yaffs_close(int fd) +int yaffs_open(const YCHAR *path, int oflag, int mode) { - yaffsfs_Handle *h = NULL; - int retVal = 0; + return yaffs_open_sharing(path, oflag, mode, + YAFFS_SHARE_READ | YAFFS_SHARE_WRITE); +} + +int yaffs_Dofsync(int handle, int datasync) +{ + int retVal = -1; + struct yaffs_obj *obj; yaffsfs_Lock(); - h = yaffsfs_GetHandlePointer(fd); + obj = yaffsfs_HandleToObject(handle); - if(h && h->inUse) - { - // clean up - yaffs_FlushFile(h->obj,1); - h->obj->inUse--; - if(h->obj->inUse <= 0 && h->obj->unlinked) - { - yaffs_DeleteFile(h->obj); - } - yaffsfs_PutHandle(fd); + if (!obj) + yaffsfs_SetError(-EBADF); + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else { + yaffs_flush_file(obj, 1, datasync); retVal = 0; } - else - { - // bad handle + + yaffsfs_Unlock(); + + return retVal; +} + +int yaffs_fsync(int handle) +{ + return yaffs_Dofsync(handle, 0); +} + +int yaffs_flush(int handle) +{ + return yaffs_fsync(handle); +} + +int yaffs_fdatasync(int handle) +{ + return yaffs_Dofsync(handle, 1); +} + +int yaffs_close(int handle) +{ + struct yaffsfs_Handle *h = NULL; + struct yaffs_obj *obj = NULL; + int retVal = -1; + + yaffsfs_Lock(); + + h = yaffsfs_HandleToPointer(handle); + obj = yaffsfs_HandleToObject(handle); + + if (!h || !obj) yaffsfs_SetError(-EBADF); - retVal = -1; + else { + /* clean up */ + yaffs_flush_file(obj, 1, 0); + yaffsfs_PutHandle(handle); + retVal = 0; } yaffsfs_Unlock(); @@ -517,378 +1063,774 @@ int yaffs_close(int fd) return retVal; } -int yaffs_read(int fd, void *buf, unsigned int nbyte) +int yaffsfs_do_read(int handle, void *vbuf, unsigned int nbyte, + int isPread, loff_t offset) { - yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; - int pos = 0; - int nRead = -1; - int maxRead; + struct yaffsfs_FileDes *fd = NULL; + struct yaffs_obj *obj = NULL; + loff_t pos = 0; + loff_t startPos = 0; + loff_t endPos = 0; + int nRead = 0; + int nToRead = 0; + int totalRead = 0; + loff_t maxRead; + u8 *buf = (u8 *) vbuf; + + if (!vbuf) { + yaffsfs_SetError(-EFAULT); + return -1; + } yaffsfs_Lock(); - h = yaffsfs_GetHandlePointer(fd); - obj = yaffsfs_GetHandleObject(fd); + fd = yaffsfs_HandleToFileDes(handle); + obj = yaffsfs_HandleToObject(handle); - if(!h || !obj) - { - // bad handle + if (!fd || !obj) { + /* bad handle */ yaffsfs_SetError(-EBADF); - } - else if( h && obj) - { - pos= h->position; - if(yaffs_GetObjectFileLength(obj) > pos) - { - maxRead = yaffs_GetObjectFileLength(obj) - pos; - } + totalRead = -1; + } else if (!fd->reading) { + /* Not a reading handle */ + yaffsfs_SetError(-EINVAL); + totalRead = -1; + } else if (nbyte > YAFFS_MAX_FILE_SIZE) { + yaffsfs_SetError(-EINVAL); + totalRead = -1; + } else { + if (isPread) + startPos = offset; + else + startPos = fd->position; + + pos = startPos; + + if (yaffs_get_obj_length(obj) > pos) + maxRead = yaffs_get_obj_length(obj) - pos; else - { maxRead = 0; - } - if(nbyte > maxRead) - { + if (nbyte > maxRead) nbyte = maxRead; + + yaffsfs_GetHandle(handle); + + endPos = pos + nbyte; + + if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE || + nbyte > YAFFS_MAX_FILE_SIZE || + endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) { + totalRead = -1; + nbyte = 0; } + while (nbyte > 0) { + nToRead = YAFFSFS_RW_SIZE - + (pos & (YAFFSFS_RW_SIZE - 1)); + if (nToRead > nbyte) + nToRead = nbyte; + + /* Tricky bit... + * Need to reverify object in case the device was + * unmounted in another thread. + */ + obj = yaffsfs_HandleToObject(handle); + if (!obj) + nRead = 0; + else + nRead = yaffs_file_rd(obj, buf, pos, nToRead); - if(nbyte > 0) - { - nRead = yaffs_ReadDataFromFile(obj,buf,pos,nbyte); - if(nRead >= 0) - { - h->position = pos + nRead; + if (nRead > 0) { + totalRead += nRead; + pos += nRead; + buf += nRead; } + + if (nRead == nToRead) + nbyte -= nRead; else - { - //todo error + nbyte = 0; /* no more to read */ + + if (nbyte > 0) { + yaffsfs_Unlock(); + yaffsfs_Lock(); } + } - else - { - nRead = 0; + + yaffsfs_PutHandle(handle); + + if (!isPread) { + if (totalRead >= 0) + fd->position = startPos + totalRead; + else + yaffsfs_SetError(-EINVAL); } } yaffsfs_Unlock(); + return (totalRead >= 0) ? totalRead : -1; - return (nRead >= 0) ? nRead : -1; +} +int yaffs_read(int handle, void *buf, unsigned int nbyte) +{ + return yaffsfs_do_read(handle, buf, nbyte, 0, 0); } -int yaffs_write(int fd, const void *buf, unsigned int nbyte) +int yaffs_pread(int handle, void *buf, unsigned int nbyte, loff_t offset) { - yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; - int pos = 0; - int nWritten = -1; - int writeThrough = 0; + return yaffsfs_do_read(handle, buf, nbyte, 1, offset); +} + +int yaffsfs_do_write(int handle, const void *vbuf, unsigned int nbyte, + int isPwrite, loff_t offset) +{ + struct yaffsfs_FileDes *fd = NULL; + struct yaffs_obj *obj = NULL; + loff_t pos = 0; + loff_t startPos = 0; + loff_t endPos; + int nWritten = 0; + int totalWritten = 0; + int write_trhrough = 0; + int nToWrite = 0; + const u8 *buf = (const u8 *)vbuf; + + if (!vbuf) { + yaffsfs_SetError(-EFAULT); + return -1; + } yaffsfs_Lock(); - h = yaffsfs_GetHandlePointer(fd); - obj = yaffsfs_GetHandleObject(fd); + fd = yaffsfs_HandleToFileDes(handle); + obj = yaffsfs_HandleToObject(handle); - if(!h || !obj) - { - // bad handle + if (!fd || !obj) { + /* bad handle */ yaffsfs_SetError(-EBADF); - } - else if( h && obj && h->readOnly) - { - // todo error - } - else if( h && obj) - { - if(h->append) - { - pos = yaffs_GetObjectFileLength(obj); - } + totalWritten = -1; + } else if (!fd->writing) { + yaffsfs_SetError(-EINVAL); + totalWritten = -1; + } else if (obj->my_dev->read_only) { + yaffsfs_SetError(-EROFS); + totalWritten = -1; + } else { + if (fd->append) + startPos = yaffs_get_obj_length(obj); + else if (isPwrite) + startPos = offset; else - { - pos = h->position; - } + startPos = fd->position; - nWritten = yaffs_WriteDataToFile(obj,buf,pos,nbyte,writeThrough); + yaffsfs_GetHandle(handle); + pos = startPos; + endPos = pos + nbyte; - if(nWritten >= 0) - { - h->position = pos + nWritten; + if (pos < 0 || pos > YAFFS_MAX_FILE_SIZE || + nbyte > YAFFS_MAX_FILE_SIZE || + endPos < 0 || endPos > YAFFS_MAX_FILE_SIZE) { + totalWritten = -1; + nbyte = 0; } - else - { - //todo error + + while (nbyte > 0) { + + nToWrite = YAFFSFS_RW_SIZE - + (pos & (YAFFSFS_RW_SIZE - 1)); + if (nToWrite > nbyte) + nToWrite = nbyte; + + /* Tricky bit... + * Need to reverify object in case the device was + * remounted or unmounted in another thread. + */ + obj = yaffsfs_HandleToObject(handle); + if (!obj || obj->my_dev->read_only) + nWritten = 0; + else + nWritten = + yaffs_wr_file(obj, buf, pos, nToWrite, + write_trhrough); + if (nWritten > 0) { + totalWritten += nWritten; + pos += nWritten; + buf += nWritten; + } + + if (nWritten == nToWrite) + nbyte -= nToWrite; + else + nbyte = 0; + + if (nWritten < 1 && totalWritten < 1) { + yaffsfs_SetError(-ENOSPC); + totalWritten = -1; + } + + if (nbyte > 0) { + yaffsfs_Unlock(); + yaffsfs_Lock(); + } } + yaffsfs_PutHandle(handle); + + if (!isPwrite) { + if (totalWritten > 0) + fd->position = startPos + totalWritten; + else + yaffsfs_SetError(-EINVAL); + } } yaffsfs_Unlock(); + return (totalWritten >= 0) ? totalWritten : -1; +} + +int yaffs_write(int fd, const void *buf, unsigned int nbyte) +{ + return yaffsfs_do_write(fd, buf, nbyte, 0, 0); +} + +int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, loff_t offset) +{ + return yaffsfs_do_write(fd, buf, nbyte, 1, offset); +} + +int yaffs_truncate(const YCHAR *path, loff_t new_size) +{ + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int result = YAFFS_FAIL; + int notDir = 0; + int loop = 0; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); - return (nWritten >= 0) ? nWritten : -1; + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + obj = yaffsfs_FollowLink(obj, 0, &loop); + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) + yaffsfs_SetError(-ENOENT); + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else if (obj->variant_type != YAFFS_OBJECT_TYPE_FILE) + yaffsfs_SetError(-EISDIR); + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else if (new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE) + yaffsfs_SetError(-EINVAL); + else + result = yaffs_resize_file(obj, new_size); + + yaffsfs_Unlock(); + + return (result) ? 0 : -1; } -int yaffs_truncate(int fd, off_t newSize) +int yaffs_ftruncate(int handle, loff_t new_size) { - yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; + struct yaffsfs_FileDes *fd = NULL; + struct yaffs_obj *obj = NULL; int result = 0; yaffsfs_Lock(); - h = yaffsfs_GetHandlePointer(fd); - obj = yaffsfs_GetHandleObject(fd); + fd = yaffsfs_HandleToFileDes(handle); + obj = yaffsfs_HandleToObject(handle); - if(!h || !obj) - { - // bad handle + if (!fd || !obj) + /* bad handle */ yaffsfs_SetError(-EBADF); - } + else if (!fd->writing) + yaffsfs_SetError(-EINVAL); + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else if (new_size < 0 || new_size > YAFFS_MAX_FILE_SIZE) + yaffsfs_SetError(-EINVAL); else - { - // resize the file - result = yaffs_ResizeFile(obj,newSize); - } + /* resize the file */ + result = yaffs_resize_file(obj, new_size); yaffsfs_Unlock(); - return (result) ? 0 : -1; } -off_t yaffs_lseek(int fd, off_t offset, int whence) +loff_t yaffs_lseek(int handle, loff_t offset, int whence) { - yaffsfs_Handle *h = NULL; - yaffs_Object *obj = NULL; - int pos = -1; - int fSize = -1; + struct yaffsfs_FileDes *fd = NULL; + struct yaffs_obj *obj = NULL; + loff_t pos = -1; + loff_t fSize = -1; yaffsfs_Lock(); - h = yaffsfs_GetHandlePointer(fd); - obj = yaffsfs_GetHandleObject(fd); + fd = yaffsfs_HandleToFileDes(handle); + obj = yaffsfs_HandleToObject(handle); - if(!h || !obj) - { - // bad handle + if (!fd || !obj) yaffsfs_SetError(-EBADF); - } - else if(whence == SEEK_SET) - { - if(offset >= 0) - { - pos = offset; - } - } - else if(whence == SEEK_CUR) - { - if( (h->position + offset) >= 0) - { - pos = (h->position + offset); - } - } - else if(whence == SEEK_END) - { - fSize = yaffs_GetObjectFileLength(obj); - if(fSize >= 0 && (fSize + offset) >= 0) - { - pos = fSize + offset; + else if (offset > YAFFS_MAX_FILE_SIZE) + yaffsfs_SetError(-EINVAL); + else { + if (whence == SEEK_SET) { + if (offset >= 0) + pos = offset; + } else if (whence == SEEK_CUR) { + if ((fd->position + offset) >= 0) + pos = (fd->position + offset); + } else if (whence == SEEK_END) { + fSize = yaffs_get_obj_length(obj); + if (fSize >= 0 && (fSize + offset) >= 0) + pos = fSize + offset; } - } - if(pos >= 0) - { - h->position = pos; - } - else - { - // todo error + if (pos >= 0 && pos <= YAFFS_MAX_FILE_SIZE) + fd->position = pos; + else { + yaffsfs_SetError(-EINVAL); + pos = -1; + } } - yaffsfs_Unlock(); return pos; } - -int yaffsfs_DoUnlink(const char *path,int isDirectory) +int yaffsfs_DoUnlink(const YCHAR *path, int isDirectory) { - yaffs_Object *dir = NULL; - yaffs_Object *obj = NULL; - char *name; + struct yaffs_obj *dir = NULL; + struct yaffs_obj *obj = NULL; + YCHAR *name; int result = YAFFS_FAIL; + int notDir = 0; + int loop = 0; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } yaffsfs_Lock(); - obj = yaffsfs_FindObject(NULL,path,0); - dir = yaffsfs_FindDirectory(NULL,path,&name,0); - if(!dir) - { + obj = yaffsfs_FindObject(NULL, path, 0, 0, NULL, NULL, NULL); + dir = yaffsfs_FindDirectory(NULL, path, &name, 0, &notDir, &loop); + + if (!dir && notDir) yaffsfs_SetError(-ENOTDIR); - } - else if(!obj) - { + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir) yaffsfs_SetError(-ENOENT); - } - else if(!isDirectory && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) - { + else if (yaffs_strncmp(name, _Y("."), 2) == 0) + yaffsfs_SetError(-EINVAL); + else if (!obj) + yaffsfs_SetError(-ENOENT); + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else if (!isDirectory && + obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) yaffsfs_SetError(-EISDIR); - } - else if(isDirectory && obj->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) - { + else if (isDirectory && + obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) yaffsfs_SetError(-ENOTDIR); - } - else - { - result = yaffs_Unlink(dir,name); + else if (isDirectory && obj == obj->my_dev->root_dir) + yaffsfs_SetError(-EBUSY); /* Can't rmdir a root */ + else { + result = yaffs_unlinker(dir, name); - if(result == YAFFS_FAIL && isDirectory) - { + if (result == YAFFS_FAIL && isDirectory) yaffsfs_SetError(-ENOTEMPTY); - } } yaffsfs_Unlock(); - // todo error - return (result == YAFFS_FAIL) ? -1 : 0; } -int yaffs_rmdir(const char *path) -{ - return yaffsfs_DoUnlink(path,1); -} -int yaffs_unlink(const char *path) +int yaffs_unlink(const YCHAR *path) { - return yaffsfs_DoUnlink(path,0); + return yaffsfs_DoUnlink(path, 0); } -int yaffs_rename(const char *oldPath, const char *newPath) +int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) { - yaffs_Object *olddir = NULL; - yaffs_Object *newdir = NULL; - yaffs_Object *obj = NULL; - char *oldname; - char *newname; - int result= YAFFS_FAIL; - int renameAllowed = 1; + struct yaffs_obj *olddir = NULL; + struct yaffs_obj *newdir = NULL; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *newobj = NULL; + YCHAR *oldname; + YCHAR *newname; + int result = YAFFS_FAIL; + int rename_allowed = 1; + int notOldDir = 0; + int notNewDir = 0; + int oldLoop = 0; + int newLoop = 0; - yaffsfs_Lock(); + YCHAR *alt_newpath = NULL; - olddir = yaffsfs_FindDirectory(NULL,oldPath,&oldname,0); - newdir = yaffsfs_FindDirectory(NULL,newPath,&newname,0); - obj = yaffsfs_FindObject(NULL,oldPath,0); + if (!oldPath || !newPath) { + yaffsfs_SetError(-EFAULT); + return -1; + } - if(!olddir || !newdir || !obj) - { - // bad file - yaffsfs_SetError(-EBADF); - renameAllowed = 0; + if (yaffsfs_CheckPath(oldPath) < 0 || yaffsfs_CheckPath(newPath) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; } - else if(olddir->myDev != newdir->myDev) - { - // oops must be on same device - // todo error - yaffsfs_SetError(-EXDEV); - renameAllowed = 0; + + if (yaffsfs_alt_dir_path(newPath, &alt_newpath) < 0) { + yaffsfs_SetError(-ENOMEM); + return -1; } - else if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) - { - // It is a directory, check that it is not being renamed to - // being its own decendent. - // Do this by tracing from the new directory back to the root, checking for obj + if (alt_newpath) + newPath = alt_newpath; - yaffs_Object *xx = newdir; + yaffsfs_Lock(); - while( renameAllowed && xx) - { - if(xx == obj) - { - renameAllowed = 0; - } + olddir = yaffsfs_FindDirectory(NULL, oldPath, &oldname, 0, + &notOldDir, &oldLoop); + newdir = yaffsfs_FindDirectory(NULL, newPath, &newname, 0, + &notNewDir, &newLoop); + obj = yaffsfs_FindObject(NULL, oldPath, 0, 0, NULL, NULL, NULL); + newobj = yaffsfs_FindObject(NULL, newPath, 0, 0, NULL, NULL, NULL); + + /* If the object being renamed is a directory and the + * path ended with a "/" then the olddir == obj. + * We pass through NULL for the old name to tell the lower layers + * to use olddir as the object. + */ + + if (olddir == obj) + oldname = NULL; + + if ((!olddir && notOldDir) || (!newdir && notNewDir)) { + yaffsfs_SetError(-ENOTDIR); + rename_allowed = 0; + } else if (oldLoop || newLoop) { + yaffsfs_SetError(-ELOOP); + rename_allowed = 0; + } else if (olddir && oldname && + yaffs_strncmp(oldname, _Y("."), 2) == 0) { + yaffsfs_SetError(-EINVAL); + rename_allowed = 0; + } else if (!olddir || !newdir || !obj) { + yaffsfs_SetError(-ENOENT); + rename_allowed = 0; + } else if (obj->my_dev->read_only) { + yaffsfs_SetError(-EROFS); + rename_allowed = 0; + } else if (yaffs_is_non_empty_dir(newobj)) { + yaffsfs_SetError(-ENOTEMPTY); + rename_allowed = 0; + } else if (olddir->my_dev != newdir->my_dev) { + /* Rename must be on same device */ + yaffsfs_SetError(-EXDEV); + rename_allowed = 0; + } else if (obj && obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { + /* + * It is a directory, check that it is not being renamed to + * being its own decendent. + * Do this by tracing from the new directory back to the root, + * checking for obj + */ + + struct yaffs_obj *xx = newdir; + + while (rename_allowed && xx) { + if (xx == obj) + rename_allowed = 0; xx = xx->parent; } - if(!renameAllowed) yaffsfs_SetError(-EACCESS); + if (!rename_allowed) + yaffsfs_SetError(-EINVAL); } - if(renameAllowed) - { - result = yaffs_RenameObject(olddir,oldname,newdir,newname); - } + if (rename_allowed) + result = yaffs_rename_obj(olddir, oldname, newdir, newname); yaffsfs_Unlock(); + kfree(alt_newpath); + return (result == YAFFS_FAIL) ? -1 : 0; } - -static int yaffsfs_DoStat(yaffs_Object *obj,struct yaffs_stat *buf) +static int yaffsfs_DoStat(struct yaffs_obj *obj, struct yaffs_stat *buf) { int retVal = -1; - if(obj) - { - obj = yaffs_GetEquivalentObject(obj); - } + obj = yaffs_get_equivalent_obj(obj); - if(obj && buf) - { - buf->st_dev = (int)obj->myDev->genericDevice; - buf->st_ino = obj->objectId; - buf->st_mode = obj->yst_mode & ~S_IFMT; // clear out file type bits + if (obj && buf) { + buf->st_dev = (int)obj->my_dev->os_context; + buf->st_ino = obj->obj_id; + buf->st_mode = obj->yst_mode & ~S_IFMT; - if(obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) - { + if (obj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) buf->st_mode |= S_IFDIR; - } - else if(obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) - { + else if (obj->variant_type == YAFFS_OBJECT_TYPE_SYMLINK) buf->st_mode |= S_IFLNK; - } - else if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) - { + else if (obj->variant_type == YAFFS_OBJECT_TYPE_FILE) buf->st_mode |= S_IFREG; - } - buf->st_nlink = yaffs_GetObjectLinkCount(obj); - buf->st_uid = 0; - buf->st_gid = 0;; - buf->st_rdev = obj->yst_rdev; - buf->st_size = yaffs_GetObjectFileLength(obj); - buf->st_blksize = obj->myDev->nDataBytesPerChunk; - buf->st_blocks = (buf->st_size + buf->st_blksize -1)/buf->st_blksize; - buf->yst_atime = obj->yst_atime; - buf->yst_ctime = obj->yst_ctime; - buf->yst_mtime = obj->yst_mtime; + buf->st_nlink = yaffs_get_obj_link_count(obj); + buf->st_uid = 0; + buf->st_gid = 0; + buf->st_rdev = obj->yst_rdev; + buf->st_size = yaffs_get_obj_length(obj); + buf->st_blksize = obj->my_dev->data_bytes_per_chunk; + buf->st_blocks = (buf->st_size + buf->st_blksize - 1) / + buf->st_blksize; +#if CONFIG_YAFFS_WINCE + buf->yst_wince_atime[0] = obj->win_atime[0]; + buf->yst_wince_atime[1] = obj->win_atime[1]; + buf->yst_wince_ctime[0] = obj->win_ctime[0]; + buf->yst_wince_ctime[1] = obj->win_ctime[1]; + buf->yst_wince_mtime[0] = obj->win_mtime[0]; + buf->yst_wince_mtime[1] = obj->win_mtime[1]; +#else + buf->yst_atime = obj->yst_atime; + buf->yst_ctime = obj->yst_ctime; + buf->yst_mtime = obj->yst_mtime; +#endif retVal = 0; } return retVal; } -static int yaffsfs_DoStatOrLStat(const char *path, struct yaffs_stat *buf,int doLStat) +static int yaffsfs_DoStatOrLStat(const YCHAR *path, + struct yaffs_stat *buf, int doLStat) { - yaffs_Object *obj; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int retVal = -1; + int notDir = 0; + int loop = 0; + + if (!path || !buf) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + + if (!doLStat && obj) + obj = yaffsfs_FollowLink(obj, 0, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) + yaffsfs_SetError(-ENOENT); + else + retVal = yaffsfs_DoStat(obj, buf); + + yaffsfs_Unlock(); + + return retVal; + +} + +int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf) +{ + return yaffsfs_DoStatOrLStat(path, buf, 0); +} + +int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf) +{ + return yaffsfs_DoStatOrLStat(path, buf, 1); +} + +int yaffs_fstat(int fd, struct yaffs_stat *buf) +{ + struct yaffs_obj *obj; int retVal = -1; + if (!buf) { + yaffsfs_SetError(-EFAULT); + return -1; + } + yaffsfs_Lock(); - obj = yaffsfs_FindObject(NULL,path,0); + obj = yaffsfs_HandleToObject(fd); + + if (obj) + retVal = yaffsfs_DoStat(obj, buf); + else + /* bad handle */ + yaffsfs_SetError(-EBADF); + + yaffsfs_Unlock(); + + return retVal; +} + +static int yaffsfs_DoUtime(struct yaffs_obj *obj, + const struct yaffs_utimbuf *buf) +{ + int retVal = -1; + int result; + + struct yaffs_utimbuf local; + + obj = yaffs_get_equivalent_obj(obj); + + if (obj && obj->my_dev->read_only) { + yaffsfs_SetError(-EROFS); + return -1; + } + + if (!buf) { + local.actime = Y_CURRENT_TIME; + local.modtime = local.actime; + buf = &local; + } - if(!doLStat && obj) - { - obj = yaffsfs_FollowLink(obj,0); + if (obj) { + obj->yst_atime = buf->actime; + obj->yst_mtime = buf->modtime; + obj->dirty = 1; + result = yaffs_flush_file(obj, 0, 0); + retVal = result == YAFFS_OK ? 0 : -1; + } + + return retVal; +} + +int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf) +{ + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int retVal = -1; + int notDir = 0; + int loop = 0; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; } - if(obj) - { - retVal = yaffsfs_DoStat(obj,buf); + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; } + + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) + yaffsfs_SetError(-ENOENT); else - { - // todo error not found + retVal = yaffsfs_DoUtime(obj, buf); + + yaffsfs_Unlock(); + + return retVal; + +} + +int yaffs_futime(int fd, const struct yaffs_utimbuf *buf) +{ + struct yaffs_obj *obj; + + int retVal = -1; + + yaffsfs_Lock(); + obj = yaffsfs_HandleToObject(fd); + + if (obj) + retVal = yaffsfs_DoUtime(obj, buf); + else + /* bad handle */ + yaffsfs_SetError(-EBADF); + + yaffsfs_Unlock(); + + return retVal; +} + +#ifndef CONFIG_YAFFS_WINCE +/* xattrib functions */ + +static int yaffs_do_setxattr(const YCHAR *path, const char *name, + const void *data, int size, int flags, int follow) +{ + struct yaffs_obj *obj; + struct yaffs_obj *dir; + int notDir = 0; + int loop = 0; + + int retVal = -1; + + if (!path || !name || !data) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + + if (follow) + obj = yaffsfs_FollowLink(obj, 0, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) yaffsfs_SetError(-ENOENT); + else { + retVal = yaffs_set_xattrib(obj, name, data, size, flags); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } } yaffsfs_Unlock(); @@ -897,33 +1839,41 @@ static int yaffsfs_DoStatOrLStat(const char *path, struct yaffs_stat *buf,int do } -int yaffs_stat(const char *path, struct yaffs_stat *buf) +int yaffs_setxattr(const YCHAR *path, const char *name, + const void *data, int size, int flags) { - return yaffsfs_DoStatOrLStat(path,buf,0); + return yaffs_do_setxattr(path, name, data, size, flags, 1); } -int yaffs_lstat(const char *path, struct yaffs_stat *buf) +int yaffs_lsetxattr(const YCHAR *path, const char *name, + const void *data, int size, int flags) { - return yaffsfs_DoStatOrLStat(path,buf,1); + return yaffs_do_setxattr(path, name, data, size, flags, 0); } -int yaffs_fstat(int fd, struct yaffs_stat *buf) +int yaffs_fsetxattr(int fd, const char *name, + const void *data, int size, int flags) { - yaffs_Object *obj; + struct yaffs_obj *obj; int retVal = -1; + if (!name || !data) { + yaffsfs_SetError(-EFAULT); + return -1; + } + yaffsfs_Lock(); - obj = yaffsfs_GetHandleObject(fd); + obj = yaffsfs_HandleToObject(fd); - if(obj) - { - retVal = yaffsfs_DoStat(obj,buf); - } - else - { - // bad handle + if (!obj) yaffsfs_SetError(-EBADF); + else { + retVal = yaffs_set_xattrib(obj, name, data, size, flags); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } } yaffsfs_Unlock(); @@ -931,43 +1881,128 @@ int yaffs_fstat(int fd, struct yaffs_stat *buf) return retVal; } -static int yaffsfs_DoChMod(yaffs_Object *obj,mode_t mode) +static int yaffs_do_getxattr(const YCHAR *path, const char *name, + void *data, int size, int follow) { - int result = YAFFS_FAIL; + struct yaffs_obj *obj; + struct yaffs_obj *dir; + int retVal = -1; + int notDir = 0; + int loop = 0; - if(obj) - { - obj = yaffs_GetEquivalentObject(obj); + if (!path || !name || !data) { + yaffsfs_SetError(-EFAULT); + return -1; } - if(obj) - { - obj->yst_mode = mode; - obj->dirty = 1; - result = yaffs_FlushFile(obj,0); + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; } - return result == YAFFS_OK ? 0 : -1; + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + + if (follow) + obj = yaffsfs_FollowLink(obj, 0, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) + yaffsfs_SetError(-ENOENT); + else { + retVal = yaffs_get_xattrib(obj, name, data, size); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } + } + yaffsfs_Unlock(); + + return retVal; + } +int yaffs_getxattr(const YCHAR *path, const char *name, void *data, int size) +{ + return yaffs_do_getxattr(path, name, data, size, 1); +} -int yaffs_chmod(const char *path, mode_t mode) +int yaffs_lgetxattr(const YCHAR *path, const char *name, void *data, int size) { - yaffs_Object *obj; + return yaffs_do_getxattr(path, name, data, size, 0); +} + +int yaffs_fgetxattr(int fd, const char *name, void *data, int size) +{ + struct yaffs_obj *obj; int retVal = -1; + if (!name || !data) { + yaffsfs_SetError(-EFAULT); + return -1; + } + yaffsfs_Lock(); - obj = yaffsfs_FindObject(NULL,path,0); + obj = yaffsfs_HandleToObject(fd); - if(obj) - { - retVal = yaffsfs_DoChMod(obj,mode); + if (obj) { + retVal = yaffs_get_xattrib(obj, name, data, size); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } + } else + /* bad handle */ + yaffsfs_SetError(-EBADF); + + yaffsfs_Unlock(); + + return retVal; +} + +static int yaffs_do_listxattr(const YCHAR *path, char *data, + int size, int follow) +{ + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int retVal = -1; + int notDir = 0; + int loop = 0; + + if (!path || !data) { + yaffsfs_SetError(-EFAULT); + return -1; } - else - { - // todo error not found + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + + if (follow) + obj = yaffsfs_FollowLink(obj, 0, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) yaffsfs_SetError(-ENOENT); + else { + retVal = yaffs_list_xattrib(obj, data, size); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } } yaffsfs_Unlock(); @@ -976,317 +2011,906 @@ int yaffs_chmod(const char *path, mode_t mode) } +int yaffs_listxattr(const YCHAR *path, char *data, int size) +{ + return yaffs_do_listxattr(path, data, size, 1); +} -int yaffs_fchmod(int fd, mode_t mode) +int yaffs_llistxattr(const YCHAR *path, char *data, int size) { - yaffs_Object *obj; + return yaffs_do_listxattr(path, data, size, 0); +} + +int yaffs_flistxattr(int fd, char *data, int size) +{ + struct yaffs_obj *obj; int retVal = -1; + if (!data) { + yaffsfs_SetError(-EFAULT); + return -1; + } + yaffsfs_Lock(); - obj = yaffsfs_GetHandleObject(fd); + obj = yaffsfs_HandleToObject(fd); - if(obj) - { - retVal = yaffsfs_DoChMod(obj,mode); - } - else - { - // bad handle + if (obj) { + retVal = yaffs_list_xattrib(obj, data, size); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } + } else + /* bad handle */ yaffsfs_SetError(-EBADF); + + yaffsfs_Unlock(); + + return retVal; +} + +static int yaffs_do_removexattr(const YCHAR *path, const char *name, + int follow) +{ + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int notDir = 0; + int loop = 0; + int retVal = -1; + + if (!path || !name) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + + if (follow) + obj = yaffsfs_FollowLink(obj, 0, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) + yaffsfs_SetError(-ENOENT); + else { + retVal = yaffs_remove_xattrib(obj, name); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } + } + + yaffsfs_Unlock(); + + return retVal; + +} + +int yaffs_removexattr(const YCHAR *path, const char *name) +{ + return yaffs_do_removexattr(path, name, 1); +} + +int yaffs_lremovexattr(const YCHAR *path, const char *name) +{ + return yaffs_do_removexattr(path, name, 0); +} + +int yaffs_fremovexattr(int fd, const char *name) +{ + struct yaffs_obj *obj; + + int retVal = -1; + + if (!name) { + yaffsfs_SetError(-EFAULT); + return -1; } + yaffsfs_Lock(); + obj = yaffsfs_HandleToObject(fd); + + if (obj) { + retVal = yaffs_remove_xattrib(obj, name); + if (retVal < 0) { + yaffsfs_SetError(retVal); + retVal = -1; + } + } else + /* bad handle */ + yaffsfs_SetError(-EBADF); + yaffsfs_Unlock(); return retVal; } +#endif + +#ifdef CONFIG_YAFFS_WINCE +int yaffs_get_wince_times(int fd, unsigned *wctime, + unsigned *watime, unsigned *wmtime) +{ + struct yaffs_obj *obj; + + int retVal = -1; + + yaffsfs_Lock(); + obj = yaffsfs_HandleToObject(fd); + + if (obj) { + if (wctime) { + wctime[0] = obj->win_ctime[0]; + wctime[1] = obj->win_ctime[1]; + } + if (watime) { + watime[0] = obj->win_atime[0]; + watime[1] = obj->win_atime[1]; + } + if (wmtime) { + wmtime[0] = obj->win_mtime[0]; + wmtime[1] = obj->win_mtime[1]; + } + + retVal = 0; + } else + /* bad handle */ + yaffsfs_SetError(-EBADF); + + yaffsfs_Unlock(); -int yaffs_mkdir(const char *path, mode_t mode) + return retVal; +} + +int yaffs_set_wince_times(int fd, + const unsigned *wctime, + const unsigned *watime, const unsigned *wmtime) { - yaffs_Object *parent = NULL; - yaffs_Object *dir = NULL; - char *name; - int retVal= -1; + struct yaffs_obj *obj; + int result; + int retVal = -1; yaffsfs_Lock(); - parent = yaffsfs_FindDirectory(NULL,path,&name,0); - if(parent) - dir = yaffs_MknodDirectory(parent,name,mode,0,0); - if(dir) - { + obj = yaffsfs_HandleToObject(fd); + + if (obj) { + + if (wctime) { + obj->win_ctime[0] = wctime[0]; + obj->win_ctime[1] = wctime[1]; + } + if (watime) { + obj->win_atime[0] = watime[0]; + obj->win_atime[1] = watime[1]; + } + if (wmtime) { + obj->win_mtime[0] = wmtime[0]; + obj->win_mtime[1] = wmtime[1]; + } + + obj->dirty = 1; + result = yaffs_flush_file(obj, 0, 0); retVal = 0; + } else + /* bad handle */ + yaffsfs_SetError(-EBADF); + + yaffsfs_Unlock(); + + return retVal; +} + +#endif + +static int yaffsfs_DoChMod(struct yaffs_obj *obj, mode_t mode) +{ + int result = -1; + + if (obj) + obj = yaffs_get_equivalent_obj(obj); + + if (obj) { + obj->yst_mode = mode; + obj->dirty = 1; + result = yaffs_flush_file(obj, 0, 0); + } + + return result == YAFFS_OK ? 0 : -1; +} + +int yaffs_access(const YCHAR *path, int amode) +{ + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int notDir = 0; + int loop = 0; + int retval = -1; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + if (amode & ~(R_OK | W_OK | X_OK)) { + yaffsfs_SetError(-EINVAL); + return -1; + } + + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + obj = yaffsfs_FollowLink(obj, 0, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) + yaffsfs_SetError(-ENOENT); + else if ((amode & W_OK) && obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else { + int access_ok = 1; + + if ((amode & R_OK) && !(obj->yst_mode & S_IREAD)) + access_ok = 0; + if ((amode & W_OK) && !(obj->yst_mode & S_IWRITE)) + access_ok = 0; + if ((amode & X_OK) && !(obj->yst_mode & S_IEXEC)) + access_ok = 0; + + if (!access_ok) + yaffsfs_SetError(-EACCES); + else + retval = 0; + } + + yaffsfs_Unlock(); + + return retval; + +} + +int yaffs_chmod(const YCHAR *path, mode_t mode) +{ + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int retVal = -1; + int notDir = 0; + int loop = 0; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + if (mode & ~(0777)) { + yaffsfs_SetError(-EINVAL); + return -1; + } + + yaffsfs_Lock(); + + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); + obj = yaffsfs_FollowLink(obj, 0, &loop); + + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) + yaffsfs_SetError(-ENOENT); + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); else - { - yaffsfs_SetError(-ENOSPC); // just assume no space for now - retVal = -1; + retVal = yaffsfs_DoChMod(obj, mode); + + yaffsfs_Unlock(); + + return retVal; + +} + +int yaffs_fchmod(int fd, mode_t mode) +{ + struct yaffs_obj *obj; + int retVal = -1; + + if (mode & ~(0777)) { + yaffsfs_SetError(-EINVAL); + return -1; } + yaffsfs_Lock(); + obj = yaffsfs_HandleToObject(fd); + + if (!obj) + yaffsfs_SetError(-EBADF); + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else + retVal = yaffsfs_DoChMod(obj, mode); + yaffsfs_Unlock(); return retVal; } -int yaffs_mount(const char *path) +int yaffs_mkdir(const YCHAR *path, mode_t mode) { - int retVal=-1; - int result=YAFFS_FAIL; - yaffs_Device *dev=NULL; - char *dummy; + struct yaffs_obj *parent = NULL; + struct yaffs_obj *dir = NULL; + YCHAR *name; + YCHAR *alt_path = NULL; + int retVal = -1; + int notDir = 0; + int loop = 0; - T(YAFFS_TRACE_ALWAYS,("yaffs: Mounting %s\n",path)); + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + if (yaffsfs_alt_dir_path(path, &alt_path) < 0) { + yaffsfs_SetError(-ENOMEM); + return -1; + } + if (alt_path) + path = alt_path; yaffsfs_Lock(); - dev = yaffsfs_FindDevice(path,&dummy); - if(dev) - { - if(!dev->isMounted) - { - result = yaffs_GutsInitialise(dev); - if(result == YAFFS_FAIL) - { - // todo error - mount failed - yaffsfs_SetError(-ENOMEM); + parent = yaffsfs_FindDirectory(NULL, path, &name, 0, &notDir, &loop); + if (!parent && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!parent) + yaffsfs_SetError(-ENOENT); + else if (yaffsfs_TooManyObjects(parent->my_dev)) + yaffsfs_SetError(-ENFILE); + else if (yaffs_strnlen(name, 5) == 0) { + /* Trying to make the root itself */ + yaffsfs_SetError(-EEXIST); + } else if (parent->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else { + dir = yaffs_create_dir(parent, name, mode, 0, 0); + if (dir) + retVal = 0; + else if (yaffs_find_by_name(parent, name)) + yaffsfs_SetError(-EEXIST); /* name exists */ + else + yaffsfs_SetError(-ENOSPC); /* assume no space */ + } + + yaffsfs_Unlock(); + + kfree(alt_path); + + return retVal; +} + +int yaffs_rmdir(const YCHAR *path) +{ + int result; + YCHAR *alt_path; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + if (yaffsfs_alt_dir_path(path, &alt_path) < 0) { + yaffsfs_SetError(-ENOMEM); + return -1; + } + if (alt_path) + path = alt_path; + result = yaffsfs_DoUnlink(path, 1); + + kfree(alt_path); + + return result; +} + +void *yaffs_getdev(const YCHAR *path) +{ + struct yaffs_dev *dev = NULL; + YCHAR *dummy; + dev = yaffsfs_FindDevice(path, &dummy); + return (void *)dev; +} + +int yaffs_mount_common(const YCHAR *path, int read_only, int skip_checkpt) +{ + int retVal = -1; + int result = YAFFS_FAIL; + struct yaffs_dev *dev = NULL; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + yaffs_trace(YAFFS_TRACE_MOUNT, "yaffs: Mounting %s", path); + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); + + yaffsfs_InitHandles(); + + dev = yaffsfs_FindMountPoint(path); + if (dev) { + if (!dev->is_mounted) { + dev->read_only = read_only ? 1 : 0; + if (skip_checkpt) { + u8 skip = dev->param.skip_checkpt_rd; + dev->param.skip_checkpt_rd = 1; + result = yaffs_guts_initialise(dev); + dev->param.skip_checkpt_rd = skip; + } else { + result = yaffs_guts_initialise(dev); } + + if (result == YAFFS_FAIL) + yaffsfs_SetError(-ENOMEM); retVal = result ? 0 : -1; - } - else - { - //todo error - already mounted. + } else yaffsfs_SetError(-EBUSY); - } - } - else - { - // todo error - no device + } else yaffsfs_SetError(-ENODEV); - } + yaffsfs_Unlock(); return retVal; } -int yaffs_unmount(const char *path) +int yaffs_mount2(const YCHAR *path, int readonly) { - int retVal=-1; - yaffs_Device *dev=NULL; - char *dummy; + return yaffs_mount_common(path, readonly, 0); +} + +int yaffs_mount(const YCHAR *path) +{ + return yaffs_mount_common(path, 0, 0); +} + +int yaffs_sync(const YCHAR *path) +{ + int retVal = -1; + struct yaffs_dev *dev = NULL; + YCHAR *dummy; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } yaffsfs_Lock(); - dev = yaffsfs_FindDevice(path,&dummy); - if(dev) - { - if(dev->isMounted) - { - int i; - int inUse; + dev = yaffsfs_FindDevice(path, &dummy); + if (dev) { + if (!dev->is_mounted) + yaffsfs_SetError(-EINVAL); + else if (dev->read_only) + yaffsfs_SetError(-EROFS); + else { - yaffs_FlushEntireDeviceCache(dev); - yaffs_CheckpointSave(dev); + yaffs_flush_whole_cache(dev); + yaffs_checkpoint_save(dev); + retVal = 0; - for(i = inUse = 0; i < YAFFSFS_N_HANDLES && !inUse; i++) - { - if(yaffsfs_handle[i].inUse && yaffsfs_handle[i].obj->myDev == dev) - { - inUse = 1; // the device is in use, can't unmount - } - } + } + } else + yaffsfs_SetError(-ENODEV); - if(!inUse) - { - yaffs_Deinitialise(dev); + yaffsfs_Unlock(); + return retVal; +} + +static int yaffsfs_IsDevBusy(struct yaffs_dev *dev) +{ + int i; + struct yaffs_obj *obj; + for (i = 0; i < YAFFSFS_N_HANDLES; i++) { + obj = yaffsfs_HandleToObject(i); + if (obj && obj->my_dev == dev) + return 1; + } + return 0; +} + +int yaffs_remount(const YCHAR *path, int force, int read_only) +{ + int retVal = -1; + struct yaffs_dev *dev = NULL; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); + dev = yaffsfs_FindMountPoint(path); + if (dev) { + if (dev->is_mounted) { + yaffs_flush_whole_cache(dev); + + if (force || !yaffsfs_IsDevBusy(dev)) { + if (read_only) + yaffs_checkpoint_save(dev); + dev->read_only = read_only ? 1 : 0; retVal = 0; - } - else - { - // todo error can't unmount as files are open + } else yaffsfs_SetError(-EBUSY); - } - } - else - { - //todo error - not mounted. + } else yaffsfs_SetError(-EINVAL); - } - } - else - { - // todo error - no device + } else yaffsfs_SetError(-ENODEV); - } + yaffsfs_Unlock(); return retVal; } -loff_t yaffs_freespace(const char *path) +int yaffs_unmount2(const YCHAR *path, int force) { - loff_t retVal=-1; - yaffs_Device *dev=NULL; - char *dummy; + int retVal = -1; + struct yaffs_dev *dev = NULL; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } yaffsfs_Lock(); - dev = yaffsfs_FindDevice(path,&dummy); - if(dev && dev->isMounted) - { - retVal = yaffs_GetNumberOfFreeChunks(dev); - retVal *= dev->nDataBytesPerChunk; + dev = yaffsfs_FindMountPoint(path); + if (dev) { + if (dev->is_mounted) { + int inUse; + yaffs_flush_whole_cache(dev); + yaffs_checkpoint_save(dev); + inUse = yaffsfs_IsDevBusy(dev); + if (!inUse || force) { + if (inUse) + yaffsfs_BreakDeviceHandles(dev); + yaffs_deinitialise(dev); + + retVal = 0; + } else + yaffsfs_SetError(-EBUSY); + + } else + yaffsfs_SetError(-EINVAL); + + } else + yaffsfs_SetError(-ENODEV); + + yaffsfs_Unlock(); + return retVal; + +} + +int yaffs_unmount(const YCHAR *path) +{ + return yaffs_unmount2(path, 0); +} + +loff_t yaffs_freespace(const YCHAR *path) +{ + loff_t retVal = -1; + struct yaffs_dev *dev = NULL; + YCHAR *dummy; + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; } - else - { - yaffsfs_SetError(-EINVAL); + + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; } + yaffsfs_Lock(); + dev = yaffsfs_FindDevice(path, &dummy); + if (dev && dev->is_mounted) { + retVal = yaffs_get_n_free_chunks(dev); + retVal *= dev->data_bytes_per_chunk; + + } else + yaffsfs_SetError(-EINVAL); + yaffsfs_Unlock(); return retVal; } +loff_t yaffs_totalspace(const YCHAR *path) +{ + loff_t retVal = -1; + struct yaffs_dev *dev = NULL; + YCHAR *dummy; + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } -void yaffs_initialise(yaffsfs_DeviceConfiguration *cfgList) -{ + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } - yaffsfs_DeviceConfiguration *cfg; + yaffsfs_Lock(); + dev = yaffsfs_FindDevice(path, &dummy); + if (dev && dev->is_mounted) { + retVal = (dev->param.end_block - dev->param.start_block + 1) - + dev->param.n_reserved_blocks; + retVal *= dev->param.chunks_per_block; + retVal *= dev->data_bytes_per_chunk; + + } else + yaffsfs_SetError(-EINVAL); + + yaffsfs_Unlock(); + return retVal; +} - yaffsfs_configurationList = cfgList; +int yaffs_inodecount(const YCHAR *path) +{ + loff_t retVal = -1; + struct yaffs_dev *dev = NULL; + YCHAR *dummy; - yaffsfs_InitHandles(); + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } - cfg = yaffsfs_configurationList; + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } - while(cfg && cfg->prefix && cfg->dev) - { - cfg->dev->isMounted = 0; - cfg->dev->removeObjectCallback = yaffsfs_RemoveObjectCallback; - cfg++; + yaffsfs_Lock(); + dev = yaffsfs_FindDevice(path, &dummy); + if (dev && dev->is_mounted) { + int n_obj = dev->n_obj; + if (n_obj > dev->n_hardlinks) + retVal = n_obj - dev->n_hardlinks; } + + if (retVal < 0) + yaffsfs_SetError(-EINVAL); + + yaffsfs_Unlock(); + return retVal; } +void yaffs_add_device(struct yaffs_dev *dev) +{ + struct list_head *cfg; + /* First check that the device is not in the list. */ + + list_for_each(cfg, &yaffsfs_deviceList) { + if (dev == list_entry(cfg, struct yaffs_dev, dev_list)) + return; + } + + dev->is_mounted = 0; + dev->param.remove_obj_fn = yaffsfs_RemoveObjectCallback; -// -// Directory search stuff. + if (!dev->dev_list.next) + INIT_LIST_HEAD(&dev->dev_list); -// -// Directory search context -// -// NB this is an opaque structure. + list_add(&dev->dev_list, &yaffsfs_deviceList); +} + +void yaffs_remove_device(struct yaffs_dev *dev) +{ + list_del_init(&dev->dev_list); +} +/* Functions to iterate through devices. NB Use with extreme care! */ -typedef struct +static struct list_head *dev_iterator; +void yaffs_dev_rewind(void) { - __u32 magic; - yaffs_dirent de; /* directory entry being used by this dsc */ - char name[NAME_MAX+1]; /* name of directory being searched */ - yaffs_Object *dirObj; /* ptr to directory being searched */ - yaffs_Object *nextReturn; /* obj to be returned by next readddir */ - int offset; - struct list_head others; -} yaffsfs_DirectorySearchContext; + dev_iterator = yaffsfs_deviceList.next; +} + +struct yaffs_dev *yaffs_next_dev(void) +{ + struct yaffs_dev *retval; + if (!dev_iterator) + return NULL; + if (dev_iterator == &yaffsfs_deviceList) + return NULL; + + retval = list_entry(dev_iterator, struct yaffs_dev, dev_list); + dev_iterator = dev_iterator->next; + return retval; +} +/* Directory search stuff. */ static struct list_head search_contexts; - -static void yaffsfs_SetDirRewound(yaffsfs_DirectorySearchContext *dsc) +static void yaffsfs_SetDirRewound(struct yaffsfs_DirSearchContxt *dsc) { - if(dsc && - dsc->dirObj && - dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){ + if (dsc && + dsc->dirObj && + dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { - dsc->offset = 0; + dsc->offset = 0; - if( list_empty(&dsc->dirObj->variant.directoryVariant.children)){ - dsc->nextReturn = NULL; - } else { - dsc->nextReturn = list_entry(dsc->dirObj->variant.directoryVariant.children.next, - yaffs_Object,siblings); - } + if (list_empty(&dsc->dirObj->variant.dir_variant.children)) + dsc->nextReturn = NULL; + else + dsc->nextReturn = + list_entry(dsc->dirObj->variant.dir_variant. + children.next, struct yaffs_obj, + siblings); } else { /* Hey someone isn't playing nice! */ } } -static void yaffsfs_DirAdvance(yaffsfs_DirectorySearchContext *dsc) +static void yaffsfs_DirAdvance(struct yaffsfs_DirSearchContxt *dsc) { - if(dsc && - dsc->dirObj && - dsc->dirObj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY){ - - if( dsc->nextReturn == NULL || - list_empty(&dsc->dirObj->variant.directoryVariant.children)){ - dsc->nextReturn = NULL; - } else { - struct list_head *next = dsc->nextReturn->siblings.next; - - if( next == &dsc->dirObj->variant.directoryVariant.children) - dsc->nextReturn = NULL; /* end of list */ - else - dsc->nextReturn = list_entry(next,yaffs_Object,siblings); - } + if (dsc && + dsc->dirObj && + dsc->dirObj->variant_type == YAFFS_OBJECT_TYPE_DIRECTORY) { + + if (dsc->nextReturn == NULL || + list_empty(&dsc->dirObj->variant.dir_variant.children)) + dsc->nextReturn = NULL; + else { + struct list_head *next = dsc->nextReturn->siblings.next; + + if (next == &dsc->dirObj->variant.dir_variant.children) + dsc->nextReturn = NULL; /* end of list */ + else + dsc->nextReturn = list_entry(next, + struct yaffs_obj, + siblings); + } } else { /* Hey someone isn't playing nice! */ } } -static void yaffsfs_RemoveObjectCallback(yaffs_Object *obj) +static void yaffsfs_RemoveObjectCallback(struct yaffs_obj *obj) { struct list_head *i; - yaffsfs_DirectorySearchContext *dsc; + struct yaffsfs_DirSearchContxt *dsc; /* if search contexts not initilised then skip */ - if(!search_contexts.next) + if (!search_contexts.next) return; - /* Iteratethrough the directory search contexts. + /* Iterate through the directory search contexts. * If any are the one being removed, then advance the dsc to * the next one to prevent a hanging ptr. */ - list_for_each(i, &search_contexts) { + list_for_each(i, &search_contexts) { if (i) { - dsc = list_entry(i, yaffsfs_DirectorySearchContext,others); - if(dsc->nextReturn == obj) + dsc = list_entry(i, struct yaffsfs_DirSearchContxt, + others); + if (dsc->nextReturn == obj) yaffsfs_DirAdvance(dsc); } } } -yaffs_DIR *yaffs_opendir(const char *dirname) +yaffs_DIR *yaffs_opendir(const YCHAR *dirname) { yaffs_DIR *dir = NULL; - yaffs_Object *obj = NULL; - yaffsfs_DirectorySearchContext *dsc = NULL; + struct yaffs_obj *obj = NULL; + struct yaffsfs_DirSearchContxt *dsc = NULL; + int notDir = 0; + int loop = 0; + + if (!dirname) { + yaffsfs_SetError(-EFAULT); + return NULL; + } + + if (yaffsfs_CheckPath(dirname) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return NULL; + } yaffsfs_Lock(); - obj = yaffsfs_FindObject(NULL,dirname,0); + obj = yaffsfs_FindObject(NULL, dirname, 0, 1, NULL, &notDir, &loop); + + if (!obj && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!obj) + yaffsfs_SetError(-ENOENT); + else if (obj->variant_type != YAFFS_OBJECT_TYPE_DIRECTORY) + yaffsfs_SetError(-ENOTDIR); + else { + int i; + + for (i = 0, dsc = NULL; i < YAFFSFS_N_DSC && !dsc; i++) { + if (!yaffsfs_dsc[i].inUse) + dsc = &yaffsfs_dsc[i]; + } - if(obj && obj->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) - { + dir = (yaffs_DIR *) dsc; - dsc = YMALLOC(sizeof(yaffsfs_DirectorySearchContext)); - dir = (yaffs_DIR *)dsc; - if(dsc) - { - memset(dsc,0,sizeof(yaffsfs_DirectorySearchContext)); - dsc->magic = YAFFS_MAGIC; + if (dsc) { + memset(dsc, 0, sizeof(struct yaffsfs_DirSearchContxt)); + dsc->inUse = 1; dsc->dirObj = obj; - strncpy(dsc->name,dirname,NAME_MAX); + yaffs_strncpy(dsc->name, dirname, NAME_MAX); INIT_LIST_HEAD(&dsc->others); - if(!search_contexts.next) + if (!search_contexts.next) INIT_LIST_HEAD(&search_contexts); - list_add(&dsc->others,&search_contexts); - yaffsfs_SetDirRewound(dsc); } + list_add(&dsc->others, &search_contexts); + yaffsfs_SetDirRewound(dsc); + } } @@ -1295,35 +2919,34 @@ yaffs_DIR *yaffs_opendir(const char *dirname) return dir; } -struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp) +struct yaffs_dirent *yaffs_readdir(yaffs_DIR * dirp) { - yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp; + struct yaffsfs_DirSearchContxt *dsc; struct yaffs_dirent *retVal = NULL; + dsc = (struct yaffsfs_DirSearchContxt *) dirp; yaffsfs_Lock(); - if(dsc && dsc->magic == YAFFS_MAGIC){ + if (dsc && dsc->inUse) { yaffsfs_SetError(0); - if(dsc->nextReturn){ - dsc->de.d_ino = yaffs_GetEquivalentObject(dsc->nextReturn)->objectId; + if (dsc->nextReturn) { + dsc->de.d_ino = + yaffs_get_equivalent_obj(dsc->nextReturn)->obj_id; dsc->de.d_dont_use = (unsigned)dsc->nextReturn; dsc->de.d_off = dsc->offset++; - yaffs_GetObjectName(dsc->nextReturn,dsc->de.d_name,NAME_MAX); - if(strlen(dsc->de.d_name) == 0) - { - // this should not happen! - strcpy(dsc->de.d_name,"zz"); + yaffs_get_obj_name(dsc->nextReturn, + dsc->de.d_name, NAME_MAX); + if (yaffs_strnlen(dsc->de.d_name, NAME_MAX + 1) == 0) { + /* this should not happen! */ + yaffs_strcpy(dsc->de.d_name, _Y("zz")); } dsc->de.d_reclen = sizeof(struct yaffs_dirent); retVal = &dsc->de; yaffsfs_DirAdvance(dsc); } else retVal = NULL; - } - else - { + } else yaffsfs_SetError(-EBADF); - } yaffsfs_Unlock(); @@ -1331,10 +2954,11 @@ struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp) } - void yaffs_rewinddir(yaffs_DIR *dirp) { - yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp; + struct yaffsfs_DirSearchContxt *dsc; + + dsc = (struct yaffsfs_DirSearchContxt *) dirp; yaffsfs_Lock(); @@ -1343,41 +2967,67 @@ void yaffs_rewinddir(yaffs_DIR *dirp) yaffsfs_Unlock(); } - int yaffs_closedir(yaffs_DIR *dirp) { - yaffsfs_DirectorySearchContext *dsc = (yaffsfs_DirectorySearchContext *)dirp; + struct yaffsfs_DirSearchContxt *dsc; + + dsc = (struct yaffsfs_DirSearchContxt *) dirp; + + if (!dsc) { + yaffsfs_SetError(-EFAULT); + return -1; + } yaffsfs_Lock(); - dsc->magic = 0; - list_del(&dsc->others); /* unhook from list */ - YFREE(dsc); + dsc->inUse = 0; + list_del(&dsc->others); /* unhook from list */ yaffsfs_Unlock(); return 0; } -// end of directory stuff - +/* End of directory stuff */ -int yaffs_symlink(const char *oldpath, const char *newpath) +int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath) { - yaffs_Object *parent = NULL; - yaffs_Object *obj; - char *name; - int retVal= -1; - int mode = 0; // ignore for now + struct yaffs_obj *parent = NULL; + struct yaffs_obj *obj; + YCHAR *name; + int retVal = -1; + int mode = 0; /* ignore for now */ + int notDir = 0; + int loop = 0; - yaffsfs_Lock(); - parent = yaffsfs_FindDirectory(NULL,newpath,&name,0); - obj = yaffs_MknodSymLink(parent,name,mode,0,0,oldpath); - if(obj) - { - retVal = 0; + if (!oldpath || !newpath) { + yaffsfs_SetError(-EFAULT); + return -1; } - else - { - yaffsfs_SetError(-ENOSPC); // just assume no space for now - retVal = -1; + + if (yaffsfs_CheckPath(newpath) < 0 || yaffsfs_CheckPath(oldpath) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } + + yaffsfs_Lock(); + parent = yaffsfs_FindDirectory(NULL, newpath, &name, 0, &notDir, &loop); + if (!parent && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!parent || yaffs_strnlen(name, 5) < 1) + yaffsfs_SetError(-ENOENT); + else if (yaffsfs_TooManyObjects(parent->my_dev)) + yaffsfs_SetError(-ENFILE); + else if (parent->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else if (parent) { + obj = yaffs_create_symlink(parent, name, mode, 0, 0, oldpath); + if (obj) + retVal = 0; + else if (yaffsfs_FindObject + (NULL, newpath, 0, 0, NULL, NULL, NULL)) + yaffsfs_SetError(-EEXIST); + else + yaffsfs_SetError(-ENOSPC); } yaffsfs_Unlock(); @@ -1386,90 +3036,98 @@ int yaffs_symlink(const char *oldpath, const char *newpath) } -int yaffs_readlink(const char *path, char *buf, int bufsiz) +int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz) { - yaffs_Object *obj = NULL; - int retVal; + struct yaffs_obj *obj = NULL; + struct yaffs_obj *dir = NULL; + int retVal = -1; + int notDir = 0; + int loop = 0; + if (!path || !buf) { + yaffsfs_SetError(-EFAULT); + return -1; + } yaffsfs_Lock(); - obj = yaffsfs_FindObject(NULL,path,0); + obj = yaffsfs_FindObject(NULL, path, 0, 1, &dir, &notDir, &loop); - if(!obj) - { + if (!dir && notDir) + yaffsfs_SetError(-ENOTDIR); + else if (loop) + yaffsfs_SetError(-ELOOP); + else if (!dir || !obj) yaffsfs_SetError(-ENOENT); - retVal = -1; - } - else if(obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK) - { + else if (obj->variant_type != YAFFS_OBJECT_TYPE_SYMLINK) yaffsfs_SetError(-EINVAL); - retVal = -1; - } - else - { - char *alias = obj->variant.symLinkVariant.alias; - memset(buf,0,bufsiz); - strncpy(buf,alias,bufsiz - 1); + else { + YCHAR *alias = obj->variant.symlink_variant.alias; + memset(buf, 0, bufsiz); + yaffs_strncpy(buf, alias, bufsiz - 1); retVal = 0; } yaffsfs_Unlock(); return retVal; } -int yaffs_link(const char *oldpath, const char *newpath) +int yaffs_link(const YCHAR *oldpath, const YCHAR *linkpath) { - // Creates a link called newpath to existing oldpath - yaffs_Object *obj = NULL; - yaffs_Object *target = NULL; - int retVal = 0; + /* Creates a link called newpath to existing oldpath */ + struct yaffs_obj *obj = NULL; + struct yaffs_obj *lnk = NULL; + struct yaffs_obj *obj_dir = NULL; + struct yaffs_obj *lnk_dir = NULL; + int retVal = -1; + int notDirObj = 0; + int notDirLnk = 0; + int objLoop = 0; + int lnkLoop = 0; + YCHAR *newname; + + if (!oldpath || !linkpath) { + yaffsfs_SetError(-EFAULT); + return -1; + } + if (yaffsfs_CheckPath(linkpath) < 0 || yaffsfs_CheckPath(oldpath) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } yaffsfs_Lock(); - obj = yaffsfs_FindObject(NULL,oldpath,0); - target = yaffsfs_FindObject(NULL,newpath,0); + obj = yaffsfs_FindObject(NULL, oldpath, 0, 1, + &obj_dir, &notDirObj, &objLoop); + lnk = yaffsfs_FindObject(NULL, linkpath, 0, 0, NULL, NULL, NULL); + lnk_dir = yaffsfs_FindDirectory(NULL, linkpath, &newname, + 0, &notDirLnk, &lnkLoop); - if(!obj) - { + if ((!obj_dir && notDirObj) || (!lnk_dir && notDirLnk)) + yaffsfs_SetError(-ENOTDIR); + else if (objLoop || lnkLoop) + yaffsfs_SetError(-ELOOP); + else if (!obj_dir || !lnk_dir || !obj) yaffsfs_SetError(-ENOENT); - retVal = -1; - } - else if(target) - { + else if (obj->my_dev->read_only) + yaffsfs_SetError(-EROFS); + else if (yaffsfs_TooManyObjects(obj->my_dev)) + yaffsfs_SetError(-ENFILE); + else if (lnk) yaffsfs_SetError(-EEXIST); - retVal = -1; - } - else - { - yaffs_Object *newdir = NULL; - yaffs_Object *link = NULL; - - char *newname; - - newdir = yaffsfs_FindDirectory(NULL,newpath,&newname,0); + else if (lnk_dir->my_dev != obj->my_dev) + yaffsfs_SetError(-EXDEV); + else { + retVal = yaffsfs_CheckNameLength(newname); - if(!newdir) - { - yaffsfs_SetError(-ENOTDIR); - retVal = -1; - } - else if(newdir->myDev != obj->myDev) - { - yaffsfs_SetError(-EXDEV); - retVal = -1; - } - if(newdir && strlen(newname) > 0) - { - link = yaffs_Link(newdir,newname,obj); - if(link) + if (retVal == 0) { + lnk = yaffs_link_obj(lnk_dir, newname, obj); + if (lnk) retVal = 0; - else - { + else { yaffsfs_SetError(-ENOSPC); retVal = -1; } - } } yaffsfs_Unlock(); @@ -1477,34 +3135,84 @@ int yaffs_link(const char *oldpath, const char *newpath) return retVal; } -int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev); +int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev) +{ + pathname = pathname; + mode = mode; + dev = dev; + + yaffsfs_SetError(-EINVAL); + return -1; +} + +/* + * D E B U G F U N C T I O N S + */ -int yaffs_DumpDevStruct(const char *path) +/* + * yaffs_n_handles() + * Returns number of handles attached to the object + */ +int yaffs_n_handles(const YCHAR *path) { - char *rest; + struct yaffs_obj *obj; + + if (!path) { + yaffsfs_SetError(-EFAULT); + return -1; + } - yaffs_Object *obj = yaffsfs_FindRoot(path,&rest); + if (yaffsfs_CheckPath(path) < 0) { + yaffsfs_SetError(-ENAMETOOLONG); + return -1; + } - if(obj) - { - yaffs_Device *dev = obj->myDev; + obj = yaffsfs_FindObject(NULL, path, 0, 1, NULL, NULL, NULL); + + if (obj) + return yaffsfs_CountHandles(obj); + else + return -1; +} + +int yaffs_get_error(void) +{ + return yaffsfs_GetLastError(); +} + +int yaffs_set_error(int error) +{ + yaffsfs_SetError(error); + return 0; +} + +int yaffs_dump_dev(const YCHAR *path) +{ +#if 1 + path = path; +#else + YCHAR *rest; + + struct yaffs_obj *obj = yaffsfs_FindRoot(path, &rest); + + if (obj) { + struct yaffs_dev *dev = obj->my_dev; printf("\n" - "nPageWrites.......... %d\n" - "nPageReads........... %d\n" - "nBlockErasures....... %d\n" - "nGCCopies............ %d\n" - "garbageCollections... %d\n" - "passiveGarbageColl'ns %d\n" - "\n", - dev->nPageWrites, - dev->nPageReads, - dev->nBlockErasures, - dev->nGCCopies, - dev->garbageCollections, - dev->passiveGarbageCollections - ); + "n_page_writes.......... %d\n" + "n_page_reads........... %d\n" + "n_erasures....... %d\n" + "n_gc_copies............ %d\n" + "garbageCollections... %d\n" + "passiveGarbageColl'ns %d\n" + "\n", + dev->n_page_writes, + dev->n_page_reads, + dev->n_erasures, + dev->n_gc_copies, + dev->garbageCollections, dev->passiveGarbageCollections); } +#endif return 0; } diff --git a/fs/yaffs2/yaffsfs.h b/fs/yaffs2/yaffsfs.h index 95e7a91..f2c7666 100644 --- a/fs/yaffs2/yaffsfs.h +++ b/fs/yaffs2/yaffsfs.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -26,206 +26,184 @@ #include "yportenv.h" -//typedef long off_t; -//typedef long dev_t; -//typedef unsigned long mode_t; - - #ifndef NAME_MAX #define NAME_MAX 256 #endif -#ifndef O_RDONLY -#define O_RDONLY 00 -#endif - -#ifndef O_WRONLY -#define O_WRONLY 01 -#endif - -#ifndef O_RDWR -#define O_RDWR 02 -#endif +#define YAFFS_MAX_FILE_SIZE (0x800000000LL - 1) -#ifndef O_CREAT -#define O_CREAT 0100 -#endif -#ifndef O_EXCL -#define O_EXCL 0200 -#endif - -#ifndef O_TRUNC -#define O_TRUNC 01000 -#endif +struct yaffs_dirent { + long d_ino; /* inode number */ + off_t d_off; /* offset to this dirent */ + unsigned short d_reclen; /* length of this dirent */ + YUCHAR d_type; /* type of this record */ + YCHAR d_name[NAME_MAX+1]; /* file name (null-terminated) */ + unsigned d_dont_use; /* debug: not for public consumption */ +}; -#ifndef O_APPEND -#define O_APPEND 02000 +typedef struct opaque_structure yaffs_DIR; + + + +struct yaffs_stat { + int st_dev; /* device */ + int st_ino; /* inode */ + unsigned st_mode; /* protection */ + int st_nlink; /* number of hard links */ + int st_uid; /* user ID of owner */ + int st_gid; /* group ID of owner */ + unsigned st_rdev; /* device type (if inode device) */ + loff_t st_size; /* total size, in bytes */ + unsigned long st_blksize; /* blocksize for filesystem I/O */ + unsigned long st_blocks; /* number of blocks allocated */ +#ifdef CONFIG_YAFFS_WINCE + /* Special 64-bit times for WinCE */ + unsigned long yst_wince_atime[2]; + unsigned long yst_wince_mtime[2]; + unsigned long yst_wince_ctime[2]; +#else + unsigned long yst_atime; /* time of last access */ + unsigned long yst_mtime; /* time of last modification */ + unsigned long yst_ctime; /* time of last change */ #endif +}; -#ifndef SEEK_SET -#define SEEK_SET 0 -#endif -#ifndef SEEK_CUR -#define SEEK_CUR 1 -#endif +struct yaffs_utimbuf { + unsigned long actime; + unsigned long modtime; +}; -#ifndef SEEK_END -#define SEEK_END 2 -#endif -#ifndef EBUSY -#define EBUSY 16 -#endif +int yaffs_open(const YCHAR *path, int oflag, int mode) ; -#ifndef ENODEV -#define ENODEV 19 -#endif - -#ifndef EINVAL -#define EINVAL 22 -#endif +int yaffs_close(int fd) ; +int yaffs_fsync(int fd) ; +int yaffs_fdatasync(int fd) ; +int yaffs_flush(int fd) ; /* same as yaffs_fsync() */ -#ifndef EBADF -#define EBADF 9 -#endif +int yaffs_access(const YCHAR *path, int amode); -#ifndef EACCESS -#define EACCESS 13 -#endif +int yaffs_dup(int fd); -#ifndef EXDEV -#define EXDEV 18 -#endif +int yaffs_read(int fd, void *buf, unsigned int nbyte) ; +int yaffs_write(int fd, const void *buf, unsigned int nbyte) ; -#ifndef ENOENT -#define ENOENT 2 -#endif +int yaffs_pread(int fd, void *buf, unsigned int nbyte, loff_t offset); +int yaffs_pwrite(int fd, const void *buf, unsigned int nbyte, loff_t offset); -#ifndef ENOSPC -#define ENOSPC 28 -#endif +loff_t yaffs_lseek(int fd, loff_t offset, int whence) ; -#ifndef ENOTEMPTY -#define ENOTEMPTY 39 -#endif +int yaffs_truncate(const YCHAR *path, loff_t new_size); +int yaffs_ftruncate(int fd, loff_t new_size); -#ifndef ENOMEM -#define ENOMEM 12 -#endif +int yaffs_unlink(const YCHAR *path) ; +int yaffs_rename(const YCHAR *oldPath, const YCHAR *newPath) ; -#ifndef EEXIST -#define EEXIST 17 -#endif +int yaffs_stat(const YCHAR *path, struct yaffs_stat *buf) ; +int yaffs_lstat(const YCHAR *path, struct yaffs_stat *buf) ; +int yaffs_fstat(int fd, struct yaffs_stat *buf) ; -#ifndef ENOTDIR -#define ENOTDIR 20 -#endif +int yaffs_utime(const YCHAR *path, const struct yaffs_utimbuf *buf); +int yaffs_futime(int fd, const struct yaffs_utimbuf *buf); -#ifndef EISDIR -#define EISDIR 21 -#endif +int yaffs_setxattr(const char *path, const char *name, + const void *data, int size, int flags); +int yaffs_lsetxattr(const char *path, const char *name, + const void *data, int size, int flags); +int yaffs_fsetxattr(int fd, const char *name, + const void *data, int size, int flags); -// Mode flags +int yaffs_getxattr(const char *path, const char *name, + void *data, int size); +int yaffs_lgetxattr(const char *path, const char *name, + void *data, int size); +int yaffs_fgetxattr(int fd, const char *name, + void *data, int size); -#ifndef S_IFMT -#define S_IFMT 0170000 -#endif +int yaffs_removexattr(const char *path, const char *name); +int yaffs_lremovexattr(const char *path, const char *name); +int yaffs_fremovexattr(int fd, const char *name); -#ifndef S_IFLNK -#define S_IFLNK 0120000 -#endif +int yaffs_listxattr(const char *path, char *list, int size); +int yaffs_llistxattr(const char *path, char *list, int size); +int yaffs_flistxattr(int fd, char *list, int size); -#ifndef S_IFDIR -#define S_IFDIR 0040000 -#endif -#ifndef S_IFREG -#define S_IFREG 0100000 -#endif +#ifdef CONFIG_YAFFS_WINCE -#ifndef S_IREAD -#define S_IREAD 0000400 -#endif +int yaffs_set_wince_times(int fd, + const unsigned *wctime, + const unsigned *watime, + const unsigned *wmtime); +int yaffs_get_wince_times(int fd, + unsigned *wctime, + unsigned *watime, + unsigned *wmtime); -#ifndef S_IWRITE -#define S_IWRITE 0000200 #endif +int yaffs_chmod(const YCHAR *path, mode_t mode); +int yaffs_fchmod(int fd, mode_t mode); +int yaffs_mkdir(const YCHAR *path, mode_t mode) ; +int yaffs_rmdir(const YCHAR *path) ; +yaffs_DIR *yaffs_opendir(const YCHAR *dirname) ; +struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp) ; +void yaffs_rewinddir(yaffs_DIR *dirp) ; +int yaffs_closedir(yaffs_DIR *dirp) ; -struct yaffs_dirent{ - long d_ino; /* inode number */ - off_t d_off; /* offset to this dirent */ - unsigned short d_reclen; /* length of this d_name */ - char d_name [NAME_MAX+1]; /* file name (null-terminated) */ - unsigned d_dont_use; /* debug pointer, not for public consumption */ -}; - -typedef struct yaffs_dirent yaffs_dirent; - - -typedef struct __opaque yaffs_DIR; - +int yaffs_mount(const YCHAR *path) ; +int yaffs_mount2(const YCHAR *path, int read_only); +int yaffs_mount_common(const YCHAR *path, int read_only, int skip_checkpt); +int yaffs_unmount(const YCHAR *path) ; +int yaffs_unmount2(const YCHAR *path, int force); +int yaffs_remount(const YCHAR *path, int force, int read_only); -struct yaffs_stat{ - int st_dev; /* device */ - int st_ino; /* inode */ - mode_t st_mode; /* protection */ - int st_nlink; /* number of hard links */ - int st_uid; /* user ID of owner */ - int st_gid; /* group ID of owner */ - unsigned st_rdev; /* device type (if inode device) */ - off_t st_size; /* total size, in bytes */ - unsigned long st_blksize; /* blocksize for filesystem I/O */ - unsigned long st_blocks; /* number of blocks allocated */ - unsigned long yst_atime; /* time of last access */ - unsigned long yst_mtime; /* time of last modification */ - unsigned long yst_ctime; /* time of last change */ -}; -int yaffs_open(const char *path, int oflag, int mode) ; -int yaffs_read(int fd, void *buf, unsigned int nbyte) ; -int yaffs_write(int fd, const void *buf, unsigned int nbyte) ; -int yaffs_close(int fd) ; -off_t yaffs_lseek(int fd, off_t offset, int whence) ; -int yaffs_truncate(int fd, off_t newSize); +int yaffs_sync(const YCHAR *path) ; -int yaffs_unlink(const char *path) ; -int yaffs_rename(const char *oldPath, const char *newPath) ; +int yaffs_symlink(const YCHAR *oldpath, const YCHAR *newpath); +int yaffs_readlink(const YCHAR *path, YCHAR *buf, int bufsiz); -int yaffs_stat(const char *path, struct yaffs_stat *buf) ; -int yaffs_lstat(const char *path, struct yaffs_stat *buf) ; -int yaffs_fstat(int fd, struct yaffs_stat *buf) ; +int yaffs_link(const YCHAR *oldpath, const YCHAR *newpath); +int yaffs_mknod(const YCHAR *pathname, mode_t mode, dev_t dev); -int yaffs_chmod(const char *path, mode_t mode); -int yaffs_fchmod(int fd, mode_t mode); +loff_t yaffs_freespace(const YCHAR *path); +loff_t yaffs_totalspace(const YCHAR *path); -int yaffs_mkdir(const char *path, mode_t mode) ; -int yaffs_rmdir(const char *path) ; +int yaffs_inodecount(const YCHAR *path); -yaffs_DIR *yaffs_opendir(const char *dirname) ; -struct yaffs_dirent *yaffs_readdir(yaffs_DIR *dirp) ; -void yaffs_rewinddir(yaffs_DIR *dirp) ; -int yaffs_closedir(yaffs_DIR *dirp) ; +int yaffs_n_handles(const YCHAR *path); -int yaffs_mount(const char *path) ; -int yaffs_unmount(const char *path) ; +#define YAFFS_SHARE_READ 1 +#define YAFFS_SHARE_WRITE 2 +int yaffs_open_sharing(const YCHAR *path, int oflag, int mode, int shareMode); -int yaffs_symlink(const char *oldpath, const char *newpath); -int yaffs_readlink(const char *path, char *buf, int bufsiz); +struct yaffs_dev; +void yaffs_add_device(struct yaffs_dev *dev); -int yaffs_link(const char *oldpath, const char *newpath); -int yaffs_mknod(const char *pathname, mode_t mode, dev_t dev); +int yaffs_start_up(void); +int yaffsfs_GetLastError(void); -loff_t yaffs_freespace(const char *path); +/* Functions to iterate through devices. NB Use with extreme care! */ +void yaffs_dev_rewind(void); +struct yaffs_dev *yaffs_next_dev(void); -void yaffs_initialise(yaffsfs_DeviceConfiguration *configList); +/* Function to get the last error */ +int yaffs_get_error(void); +const char *yaffs_error_to_str(int err); -int yaffs_StartUp(void); +/* Function only for debugging */ +void *yaffs_getdev(const YCHAR *path); +int yaffs_dump_dev(const YCHAR *path); +int yaffs_set_error(int error); +/* Trace control functions */ +unsigned yaffs_set_trace(unsigned tm); +unsigned yaffs_get_trace(void); #endif diff --git a/fs/yaffs2/yaffsinterface.h b/fs/yaffs2/yaffsinterface.h deleted file mode 100644 index 810837a..0000000 --- a/fs/yaffs2/yaffsinterface.h +++ /dev/null @@ -1,21 +0,0 @@ -/* - * YAFFS: Yet another Flash File System . A NAND-flash specific file system. - * - * Copyright (C) 2002-2007 Aleph One Ltd. - * for Toby Churchill Ltd and Brightstar Engineering - * - * Created by Charles Manning <charles(a)aleph1.co.uk> - * - * 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 __YAFFSINTERFACE_H__ -#define __YAFFSINTERFACE_H__ - -int yaffs_Initialise(unsigned nBlocks); - -#endif diff --git a/fs/yaffs2/ydirectenv.h b/fs/yaffs2/ydirectenv.h index b555810..eff8ff9 100644 --- a/fs/yaffs2/ydirectenv.h +++ b/fs/yaffs2/ydirectenv.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -20,73 +20,77 @@ #ifndef __YDIRECTENV_H__ #define __YDIRECTENV_H__ -/* Direct interface */ - -#include "devextras.h" - -/* XXX U-BOOT XXX */ -#if 0 #include "stdlib.h" #include "stdio.h" #include "string.h" -#include "assert.h" -#endif -#include "yaffs_malloc.h" +#include "yaffs_osglue.h" +#include "yaffs_hweight.h" + +void yaffs_bug_fn(const char *file_name, int line_no); + +#define BUG() do { yaffs_bug_fn(__FILE__, __LINE__); } while (0) -/* XXX U-BOOT XXX */ -#if 0 -#define YBUG() assert(1) -#endif #define YCHAR char #define YUCHAR unsigned char #define _Y(x) x -#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_strlen(s) strlen(s) -#define yaffs_sprintf sprintf -#define yaffs_toupper(a) toupper(a) - -#ifdef NO_Y_INLINE -#define Y_INLINE + +#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) +#ifdef CONFIG_YAFFS_CASE_INSENSITIVE +#define yaffs_strcmp(a, b) strcasecmp(a, b) +#define yaffs_strncmp(a, b, c) strncasecmp(a, b, c) #else -#define Y_INLINE inline +#define yaffs_strcmp(a, b) strcmp(a, b) +#define yaffs_strncmp(a, b, c) strncmp(a, b, c) #endif -#define YMALLOC(x) yaffs_malloc(x) -#define YFREE(x) free(x) -#define YMALLOC_ALT(x) yaffs_malloc(x) -#define YFREE_ALT(x) free(x) +#define hweight8(x) yaffs_hweight8(x) +#define hweight32(x) yaffs_hweight32(x) -#define YMALLOC_DMA(x) yaffs_malloc(x) +void yaffs_qsort(void *aa, size_t n, size_t es, + int (*cmp)(const void *, const void *)); -#define YYIELD() do {} while(0) +#define sort(base, n, sz, cmp_fn, swp) yaffs_qsort(base, n, sz, cmp_fn) +#define YAFFS_PATH_DIVIDERS "/" +#ifdef NO_inline +#define inline +#else +#define inline __inline__ +#endif -//#define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) -//#define YALERT(s) YINFO(s) +#define kmalloc(x, flags) yaffsfs_malloc(x) +#define kfree(x) yaffsfs_free(x) +#define vmalloc(x) yaffsfs_malloc(x) +#define vfree(x) yaffsfs_free(x) +#define cond_resched() do {} while (0) -#define TENDSTR "\n" -#define TSTR(x) x -#define TOUT(p) printf p +#define yaffs_trace(msk, fmt, ...) do { \ + if (yaffs_trace_mask & (msk)) \ + printf("yaffs: " fmt "\n", ##__VA_ARGS__); \ +} while (0) #define YAFFS_LOSTNFOUND_NAME "lost+found" #define YAFFS_LOSTNFOUND_PREFIX "obj" -//#define YPRINTF(x) printf x #include "yaffscfg.h" #define Y_CURRENT_TIME yaffsfs_CurrentTime() #define Y_TIME_CONVERT(x) x -#define YAFFS_ROOT_MODE 0666 +#define YAFFS_ROOT_MODE 0666 #define YAFFS_LOSTNFOUND_MODE 0666 -#define yaffs_SumCompare(x,y) ((x) == (y)) -#define yaffs_strcmp(a,b) strcmp(a,b) +#include "yaffs_list.h" + +#include "yaffsfs.h" #endif + + diff --git a/fs/yaffs2/yportenv.h b/fs/yaffs2/yportenv.h index bbab14d..b47a4d6 100644 --- a/fs/yaffs2/yportenv.h +++ b/fs/yaffs2/yportenv.h @@ -1,7 +1,7 @@ /* * YAFFS: Yet another Flash File System . A NAND-flash specific file system. * - * Copyright (C) 2002-2007 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning <charles(a)aleph1.co.uk> @@ -17,82 +17,62 @@ #ifndef __YPORTENV_H__ #define __YPORTENV_H__ -/* XXX U-BOOT XXX */ -#ifndef CONFIG_YAFFS_DIRECT -#define CONFIG_YAFFS_DIRECT + +/* Definition of types */ +#ifdef CONFIG_YAFFS_DEFINES_TYPES +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned u32; #endif -#if defined CONFIG_YAFFS_WINCE -#include "ywinceenv.h" +#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 + + +/* + * Attribute flags. + * These are or-ed together to select 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; +}; -/* XXX U-BOOT XXX */ -#elif 0 /* defined __KERNEL__ */ - -#include "moduleconfig.h" - -/* Linux kernel */ -#include <linux/version.h> -#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> - -#define YCHAR char -#define YUCHAR unsigned char -#define _Y(x) x -#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_strlen(s) strlen(s) -#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_KERNEL) -#define YFREE(x) kfree(x) -#define YMALLOC_ALT(x) vmalloc(x) -#define YFREE_ALT(x) vfree(x) -#define YMALLOC_DMA(x) YMALLOC(x) - -// KR - added for use in scan so processes aren't blocked indefinitely. -#define YYIELD() schedule() - -#define YAFFS_ROOT_MODE 0666 -#define YAFFS_LOSTNFOUND_MODE 0666 - -#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_SumCompare(x,y) ((x) == (y)) -#define yaffs_strcmp(a,b) strcmp(a,b) -#define TENDSTR "\n" -#define TSTR(x) KERN_WARNING x -#define TOUT(p) printk p -#define yaffs_trace(mask, fmt, args...) \ - do { if ((mask) & (yaffs_traceMask|YAFFS_TRACE_ERROR)) \ - printk(KERN_WARNING "yaffs: " fmt, ## args); \ - } while (0) +#if defined CONFIG_YAFFS_WINCE + +#include "ywinceenv.h" -#define compile_time_assertion(assertion) \ - ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; }) #elif defined CONFIG_YAFFS_DIRECT @@ -101,93 +81,228 @@ #elif defined CONFIG_YAFFS_UTIL -/* Stuff for YAFFS utilities */ +#include "yutilsenv.h" -#include "stdlib.h" -#include "stdio.h" -#include "string.h" +#else +/* Should have specified a configuration type */ +#error Unknown configuration -#include "devextras.h" +#endif -#define YMALLOC(x) malloc(x) -#define YFREE(x) free(x) -#define YMALLOC_ALT(x) malloc(x) -#define YFREE_ALT(x) free(x) +#if defined(CONFIG_YAFFS_DIRECT) || defined(CONFIG_YAFFS_WINCE) -#define YCHAR char -#define YUCHAR unsigned char -#define _Y(x) x -#define yaffs_strcpy(a,b) strcpy(a,b) -#define yaffs_strncpy(a,b,c) strncpy(a,b,c) -#define yaffs_strlen(s) strlen(s) -#define yaffs_sprintf sprintf -#define yaffs_toupper(a) toupper(a) +#ifdef CONFIG_YAFFSFS_PROVIDE_VALUES -#define Y_INLINE inline +#ifndef O_RDONLY +#define O_RDONLY 00 +#endif -/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */ -/* #define YALERT(s) YINFO(s) */ +#ifndef O_WRONLY +#define O_WRONLY 01 +#endif -#define TENDSTR "\n" -#define TSTR(x) x -#define TOUT(p) printf p +#ifndef O_RDWR +#define O_RDWR 02 +#endif -#define YAFFS_LOSTNFOUND_NAME "lost+found" -#define YAFFS_LOSTNFOUND_PREFIX "obj" -/* #define YPRINTF(x) printf x */ +#ifndef O_CREAT +#define O_CREAT 0100 +#endif -#define YAFFS_ROOT_MODE 0666 -#define YAFFS_LOSTNFOUND_MODE 0666 +#ifndef O_EXCL +#define O_EXCL 0200 +#endif -#define yaffs_SumCompare(x,y) ((x) == (y)) -#define yaffs_strcmp(a,b) strcmp(a,b) +#ifndef O_TRUNC +#define O_TRUNC 01000 +#endif -#else -/* Should have specified a configuration type */ -#error Unknown configuration +#ifndef O_APPEND +#define O_APPEND 02000 +#endif +#ifndef SEEK_SET +#define SEEK_SET 0 #endif -/* see yaffs_fs.c */ -extern unsigned int yaffs_traceMask; -extern unsigned int yaffs_wr_attempts; +#ifndef SEEK_CUR +#define SEEK_CUR 1 +#endif -/* - * Tracing flags. - * The flags masked in YAFFS_TRACE_ALWAYS are always traced. - */ +#ifndef SEEK_END +#define SEEK_END 2 +#endif + +#ifndef EBUSY +#define EBUSY 16 +#endif + +#ifndef ENODEV +#define ENODEV 19 +#endif + +#ifndef EINVAL +#define EINVAL 22 +#endif + +#ifndef ENFILE +#define ENFILE 23 +#endif + +#ifndef EBADF +#define EBADF 9 +#endif + +#ifndef EACCES +#define EACCES 13 +#endif + +#ifndef EXDEV +#define EXDEV 18 +#endif + +#ifndef ENOENT +#define ENOENT 2 +#endif + +#ifndef ENOSPC +#define ENOSPC 28 +#endif + +#ifndef EROFS +#define EROFS 30 +#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 EFAULT +#define EFAULT 14 +#endif + +#ifndef EEXIST +#define EEXIST 17 +#endif + +#ifndef ENOTDIR +#define ENOTDIR 20 +#endif + +#ifndef EISDIR +#define EISDIR 21 +#endif + +#ifndef ELOOP +#define ELOOP 40 +#endif + + +/* Mode flags */ + +#ifndef S_IFMT +#define S_IFMT 0170000 +#endif + +#ifndef S_IFSOCK +#define S_IFSOCK 0140000 +#endif + +#ifndef S_IFIFO +#define S_IFIFO 0010000 +#endif + +#ifndef S_IFCHR +#define S_IFCHR 0020000 +#endif + +#ifndef S_IFBLK +#define S_IFBLK 0060000 +#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 + +#define S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK) +#define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK) +#define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) +#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) +#define S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK) +#define S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR) +#define S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO) + + +#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 -#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_ERROR 0x40000000 -#define YAFFS_TRACE_BUG 0x80000000 -#define YAFFS_TRACE_ALWAYS 0xF0000000 - - -#define T(mask,p) do{ if((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p);} while(0) - -#ifndef CONFIG_YAFFS_WINCE -#define YBUG() T(YAFFS_TRACE_BUG,(TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),__LINE__)) +#ifndef BUG +#define BUG() do {\ + yaffs_trace(YAFFS_TRACE_BUG,\ + "==>> yaffs bug: " __FILE__ " %d",\ + __LINE__);\ + Y_DUMP_STACK();\ +} while (0) #endif #endif -- 1.7.0.4

2 3

[U-Boot] [PATCH 0/8] i.MX25: Miscellaneus fixes
by Timo Ketola 13 Aug '12

13 Aug '12

These are the fixes I needed to do to get my board going. [PATCH 1/8] i.MX25: add mxc_get_clock infrastructure SD-controller (fsl_esdhc.c) needs a clock frequency in gd->sdhc_clk. I tried to follow the idea of other architectures. [PATCH 2/8] i.MX: Add target flashable to offset 0 Helps flashing with openocd [PATCH 4/8] i.MX25: Has a GPIO4 too GPIO4 is used in our board [PATCH 5/8] MXC FEC: Resolve speed before configuring gasket Without this 10BaseT doesn't work First and second OOB bytes are used for bad block indication USB controller in the i.MX25 has PORTSC register like the controller in i.MX31 BTW, I can't understand what is the meaning of writing into &ehci->control. I can't find such a register from reference manuals of i.MX25, 28 nor 31. [PATCH 3/8] Build: Ignore build tree and IDE control file [PATCH 6/8] i.MX25: Add Exertus EXE4026 board Maybe these does not belong into this series but I didn't know how to exclude them from this series.

8 109

[U-Boot] [PATCH 0/2] zfs: Add filesystem ZFS support
by Jorgen Lundman 10 Aug '12

10 Aug '12

ZFS filesystem support from GRUB. Adding 'zfsload' and 'zfsls' commands for ZFS filesystem support. ZFS pool notation syntax is in the format '/POOLNAME/@/directory/directory/file', also explained in help output. Initial revision given to GRUB is found: http://src.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/grub/grub-0.9… Using "either version 2 of the License, or (at your option) any later version." Jorgen Lundman (2): ZFS header files zfs: Add ZFS filesystem support Makefile | 2 +- common/Makefile | 1 + common/cmd_zfs.c | 244 +++++ fs/Makefile | 1 + fs/{ => zfs}/Makefile | 43 +- fs/zfs/dev.c | 139 +++ fs/zfs/zfs.c | 2414 ++++++++++++++++++++++++++++++++++++++++++ fs/zfs/zfs_fletcher.c | 84 ++ fs/zfs/zfs_lzjb.c | 94 ++ fs/zfs/zfs_sha256.c | 145 +++ include/config_cmd_all.h | 1 + include/zfs/dmu.h | 119 +++ include/zfs/dmu_objset.h | 43 + include/zfs/dnode.h | 80 ++ include/zfs/dsl_dataset.h | 52 + include/zfs/dsl_dir.h | 48 + include/zfs/sa_impl.h | 34 + include/zfs/spa.h | 311 ++++++ include/zfs/uberblock_impl.h | 57 + include/zfs/vdev_impl.h | 69 ++ include/zfs/zap_impl.h | 112 ++ include/zfs/zap_leaf.h | 103 ++ include/zfs/zfs.h | 122 +++ include/zfs/zfs_acl.h | 55 + include/zfs/zfs_znode.h | 70 ++ include/zfs/zil.h | 56 + include/zfs/zio.h | 92 ++ include/zfs/zio_checksum.h | 49 + include/zfs_common.h | 94 ++ 29 files changed, 4718 insertions(+), 16 deletions(-) create mode 100644 common/cmd_zfs.c copy fs/{ => zfs}/Makefile (52%) create mode 100644 fs/zfs/dev.c create mode 100644 fs/zfs/zfs.c create mode 100644 fs/zfs/zfs_fletcher.c create mode 100644 fs/zfs/zfs_lzjb.c create mode 100644 fs/zfs/zfs_sha256.c create mode 100644 include/zfs/dmu.h create mode 100644 include/zfs/dmu_objset.h create mode 100644 include/zfs/dnode.h create mode 100644 include/zfs/dsl_dataset.h create mode 100644 include/zfs/dsl_dir.h create mode 100644 include/zfs/sa_impl.h create mode 100644 include/zfs/spa.h create mode 100644 include/zfs/uberblock_impl.h create mode 100644 include/zfs/vdev_impl.h create mode 100644 include/zfs/zap_impl.h create mode 100644 include/zfs/zap_leaf.h create mode 100644 include/zfs/zfs.h create mode 100644 include/zfs/zfs_acl.h create mode 100644 include/zfs/zfs_znode.h create mode 100644 include/zfs/zil.h create mode 100644 include/zfs/zio.h create mode 100644 include/zfs/zio_checksum.h create mode 100644 include/zfs_common.h

5 34

[U-Boot] Sandbox question
by Wolfgang Denk 10 Aug '12

10 Aug '12

Hello, I have a few sandbox related questions (examples run on v2012.04) 1) Memory map - What is it supposed to look like? I get "DRAM: 128 MiB", and =>bdi boot_params = 0x00000000 DRAM bank = 0x00000000 -> start = 0x00000000 -> size = 0x08000000 FB base = 0x00000000 Yet I get: =>md 0x100 00000100:Segmentation fault 2) Sandbox does no handle EOF on stadin; this makes it impossible to use it in test scripts. For example, something like this should work: $ echo printenv | ./u-boot [As woraround I have to use ``echo 'printenv;reset' | ./u-boot''; this works, but is not really intuitive nore useful.] 3) For automatic test suites it would make a lot of sense if the return code of U-Boot was the return code of the last executed command (expecially when termination of U-Boot is the result of encountering EOF on stdin). What do you think? Best regards, Wolfgang Denk -- DENX Software Engineering GmbH, MD: Wolfgang Denk & Detlev Zundel HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany Phone: (+49)-8142-66989-10 Fax: (+49)-8142-66989-80 Email: wd(a)denx.de There is is no reason for any individual to have a computer in their home. -- Ken Olsen (President of Digital Equipment Corporation), Convention of the World Future Society, in Boston, 1977

5 18

[U-Boot] [PATCH] disk: generate GUID Partiton Tables
by Donghwa Lee 10 Aug '12

10 Aug '12

This patch manipulates GUID Papartition Tables. I send this patch on behalf of Gwuieon Jin. Signed-off-by: Gwuieon Jin <ge.jin(a)samsung.com> Signed-off-by: Kyungmin Park <kyungmin.park(a)samsung.com> --- disk/part_efi.c | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ disk/part_efi.h | 2 + include/part.h | 2 + 3 files changed, 111 insertions(+), 0 deletions(-) diff --git a/disk/part_efi.c b/disk/part_efi.c index b6cda57..ce25ad5 100644 --- a/disk/part_efi.c +++ b/disk/part_efi.c @@ -433,4 +433,111 @@ static int is_pte_valid(gpt_entry * pte) return 1; } } + +void set_gpt_table(block_dev_desc_t *dev_desc, unsigned int part_start_lba, + int parts, unsigned int *blocks, unsigned int *part_offset) +{ + legacy_mbr protective_mbr; + gpt_header p_gpt_head, s_gpt_head; + gpt_entry p_gpt_entry[GPT_ENTRY_NUMBERS], + s_gpt_entry[GPT_ENTRY_NUMBERS]; + efi_guid_t disk_uuid, part_uuid; + unsigned long crc32_tmp, tmp_val; + unsigned int size = 0; + unsigned int offset = part_start_lba; + int i; + + memset(&protective_mbr, 0, sizeof(legacy_mbr)); + memset(&p_gpt_head, 0, sizeof(gpt_header)); + memset(&s_gpt_head, 0, sizeof(gpt_header)); + memset(p_gpt_entry, 0, GPT_ENTRY_NUMBERS * sizeof(gpt_entry)); + memset(s_gpt_entry, 0, GPT_ENTRY_NUMBERS * sizeof(gpt_entry)); + + /* protective MBR (LBA0) */ + *(unsigned short *) protective_mbr.signature = MSDOS_MBR_SIGNATURE; + protective_mbr.partition_record[0].sys_ind = EFI_PMBR_OSTYPE_EFI_GPT; + tmp_val = 1UL; + memcpy(protective_mbr.partition_record[0].start_sect, &tmp_val, 4); + tmp_val = (unsigned long) (dev_desc->lba - 1); + memcpy(protective_mbr.partition_record[0].nr_sects, &tmp_val, 4); + dev_desc->block_write(dev_desc->dev, 0, 1, &protective_mbr); + + /* primary GPT header (LBA1) */ + *(unsigned long long *) p_gpt_head.signature = GPT_HEADER_SIGNATURE; + *(unsigned long *) p_gpt_head.revision = GPT_HEADER_REVISION_V1; + *(unsigned long *) p_gpt_head.header_size = sizeof(gpt_header); + *(unsigned long long *) p_gpt_head.my_lba = 1; + *(unsigned long long *) p_gpt_head.alternate_lba = dev_desc->lba - 1; + *(unsigned long long *) p_gpt_head.first_usable_lba = 34; + *(unsigned long long *) p_gpt_head.last_usable_lba = dev_desc->lba - 34; + *(unsigned long long *) p_gpt_head.partition_entry_lba = 2; + *(unsigned long *) p_gpt_head.num_partition_entries = GPT_ENTRY_NUMBERS; + *(unsigned long *) p_gpt_head.sizeof_partition_entry = GPT_ENTRY_SIZE; + *(unsigned long *) p_gpt_head.header_crc32 = 0; + *(unsigned long *) p_gpt_head.partition_entry_array_crc32 = 0; + + /* primary partition entrys (LBA2-33) */ + for (i = 0; i < parts; i++) { + memcpy(p_gpt_entry[i].partition_type_guid.b, + &PARTITION_BASIC_DATA_GUID, 16); + + *(unsigned long long *) p_gpt_entry[i].starting_lba = offset; + /* allocate remaining memory in last partition */ + if (i != parts - 1) + *(unsigned long long *) p_gpt_entry[i].ending_lba = + offset + blocks[i] - 1; + else + *(unsigned long long *) p_gpt_entry[i].ending_lba = + dev_desc->lba - 33; + memset(&p_gpt_entry[i].attributes, 0, + sizeof(gpt_entry_attributes)); + part_offset[i] = offset; + offset += blocks[i]; + } + + crc32_tmp = efi_crc32((const unsigned char *)p_gpt_entry, + le32_to_int(p_gpt_head.num_partition_entries) * + le32_to_int(p_gpt_head.sizeof_partition_entry)); + memcpy(p_gpt_head.partition_entry_array_crc32, &crc32_tmp, + sizeof(crc32_tmp)); + + crc32_tmp = efi_crc32((const unsigned char *)&p_gpt_head, + le32_to_int(p_gpt_head.header_size)); + memcpy(p_gpt_head.header_crc32, &crc32_tmp, sizeof(crc32_tmp)); + + dev_desc->block_write(dev_desc->dev, 1, 1, &p_gpt_head); + dev_desc->block_write(dev_desc->dev, 2, 32, p_gpt_entry); + + /* secondary partition entrys */ + memcpy(s_gpt_entry, p_gpt_entry, + GPT_ENTRY_NUMBERS * sizeof(gpt_entry)); + + /* secondary gpt header */ + memcpy(&s_gpt_head, &p_gpt_head, sizeof(gpt_header)); + *(unsigned long long *) s_gpt_head.my_lba = + le64_to_int(p_gpt_head.alternate_lba); + *(unsigned long long *) s_gpt_head.alternate_lba = + le64_to_int(p_gpt_head.my_lba); + *(unsigned long long *) s_gpt_head.partition_entry_lba = + le64_to_int(p_gpt_head.last_usable_lba) + 1; + *(unsigned long *) s_gpt_head.header_crc32 = 0; + *(unsigned long *) s_gpt_head.partition_entry_array_crc32 = 0; + + crc32_tmp = efi_crc32((const unsigned char *)s_gpt_entry, + le32_to_int(s_gpt_head.num_partition_entries) * + le32_to_int(s_gpt_head.sizeof_partition_entry)); + memcpy(s_gpt_head.partition_entry_array_crc32, &crc32_tmp, + sizeof(unsigned long)); + + crc32_tmp = efi_crc32((const unsigned char *)&s_gpt_head, + le32_to_int(s_gpt_head.header_size)); + memcpy(s_gpt_head.header_crc32, &crc32_tmp, sizeof(unsigned long)); + + dev_desc->block_write(dev_desc->dev, + le64_to_int(s_gpt_head.partition_entry_lba), + 32, s_gpt_entry); + dev_desc->block_write(dev_desc->dev, + le64_to_int(s_gpt_head.partition_entry_lba) + 32, + 1, &s_gpt_head); +} #endif diff --git a/disk/part_efi.h b/disk/part_efi.h index 5903e7c..ddc2a7f 100644 --- a/disk/part_efi.h +++ b/disk/part_efi.h @@ -41,6 +41,8 @@ #define GPT_HEADER_REVISION_V1 0x00010000 #define GPT_PRIMARY_PARTITION_TABLE_LBA 1ULL #define GPT_ENTRY_NAME "gpt" +#define GPT_ENTRY_NUMBERS 128 +#define GPT_ENTRY_SIZE 128 #define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \ ((efi_guid_t) \ diff --git a/include/part.h b/include/part.h index 1827767..32c3295 100644 --- a/include/part.h +++ b/include/part.h @@ -161,6 +161,8 @@ int test_part_amiga (block_dev_desc_t *dev_desc); int get_partition_info_efi (block_dev_desc_t * dev_desc, int part, disk_partition_t *info); void print_part_efi (block_dev_desc_t *dev_desc); int test_part_efi (block_dev_desc_t *dev_desc); +void set_gpt_table(block_dev_desc_t *dev_desc, unsigned int part_start_lba, + int parts, unsigned int *blocks, unsigned int *part_offset); #endif #endif /* _PART_H */ -- 1.7.4.1

3 2

[U-Boot] [PATCH] openrisc: Work around potential relocation issues
by Julius Baxter 09 Aug '12

09 Aug '12

When reset code is in flash, the jump instructions emitted by the compiler are relative instead of absolute jumps. A fix to the reset code to make correct jumps to the beginning of code relocated to RAM have also been added. Signed-off-by: Julius Baxter <juliusbaxter(a)gmail.com> --- arch/openrisc/cpu/cpu.c | 6 +++++- arch/openrisc/cpu/start.S | 13 ++++++++----- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/arch/openrisc/cpu/cpu.c b/arch/openrisc/cpu/cpu.c index 25cd624..73ecc6f 100644 --- a/arch/openrisc/cpu/cpu.c +++ b/arch/openrisc/cpu/cpu.c @@ -151,7 +151,11 @@ extern void __reset(void); int do_reset(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { disable_interrupts(); - __reset(); + /* Code the jump to __reset here as the compiler is prone to + emitting a bad jump instruction if the function is in flash */ + __asm__("l.movhi r1,hi(__reset); \ + l.ori r1,r1,lo(__reset); \ + l.jr r1"); /* not reached, __reset does not return */ return 0; } diff --git a/arch/openrisc/cpu/start.S b/arch/openrisc/cpu/start.S index 3a42717..39c80e1 100644 --- a/arch/openrisc/cpu/start.S +++ b/arch/openrisc/cpu/start.S @@ -26,8 +26,11 @@ #define HANDLE_EXCEPTION \ l.addi r1, r1, -EXCEPTION_STACK_SIZE ;\ + l.sw 0x00(r1), r2 ;\ l.sw 0x1c(r1), r9 ;\ - l.jal _exception_handler ;\ + l.movhi r2,hi(_exception_handler) ;\ + l.ori r2,r2,lo(_exception_handler) ;\ + l.jalr r2 ;\ l.nop ;\ l.lwz r9, 0x1c(r1) ;\ l.addi r1, r1, EXCEPTION_STACK_SIZE ;\ @@ -79,8 +82,9 @@ __reset: l.bnf .L_relocvectors l.addi r4,r4, 4 #endif - - l.j _start + l.movhi r4,hi(_start) + l.ori r4,r4,lo(_start) + l.jr r4 l.nop /* bus error */ @@ -262,8 +266,7 @@ _start: .type _exception_handler,@function _exception_handler: - /* Store state (r9 already saved)*/ - l.sw 0x00(r1), r2 + /* Store state (r2 and r9 already saved)*/ l.sw 0x04(r1), r3 l.sw 0x08(r1), r4 l.sw 0x0c(r1), r5 -- 1.7.4.1

3 2

[U-Boot] [PATCH] rename EB+MCF-EV123 to its current marketing name EB+CPU5282
by Jens Scharsig (BuS Elektronik) 09 Aug '12

09 Aug '12

From: Jens Scharsig <js_at_ng(a)scharsoft.de> * rename board directory to eb_cpu5282 * rename EB+MCF-EV123_.*config to eb_cpu5282_.*config * add Maintainer for EB+CPU5282 board * rename prompt Signed-off-by: Jens Scharsig (BuS Elektronik) <esw(a)bus-elektronik.de> --- MAINTAINERS | 4 ++++ board/BuS/{EB+MCF-EV123 => eb_cpu5282}/Makefile | 0 board/BuS/{EB+MCF-EV123 => eb_cpu5282}/cfm_flash.c | 0 board/BuS/{EB+MCF-EV123 => eb_cpu5282}/cfm_flash.h | 0 board/BuS/{EB+MCF-EV123 => eb_cpu5282}/config.mk | 0 .../EB+MCF-EV123.c => eb_cpu5282/eb_cpu5282.c} | 0 board/BuS/{EB+MCF-EV123 => eb_cpu5282}/flash.c | 0 board/BuS/{EB+MCF-EV123 => eb_cpu5282}/u-boot.lds | 0 boards.cfg | 4 ++-- include/configs/{EB+MCF-EV123.h => eb_cpu5282.h} | 9 ++++----- 10 files changed, 10 insertions(+), 7 deletions(-) rename board/BuS/{EB+MCF-EV123 => eb_cpu5282}/Makefile (100%) rename board/BuS/{EB+MCF-EV123 => eb_cpu5282}/cfm_flash.c (100%) rename board/BuS/{EB+MCF-EV123 => eb_cpu5282}/cfm_flash.h (100%) rename board/BuS/{EB+MCF-EV123 => eb_cpu5282}/config.mk (100%) rename board/BuS/{EB+MCF-EV123/EB+MCF-EV123.c => eb_cpu5282/eb_cpu5282.c} (100%) rename board/BuS/{EB+MCF-EV123 => eb_cpu5282}/flash.c (100%) rename board/BuS/{EB+MCF-EV123 => eb_cpu5282}/u-boot.lds (100%) rename include/configs/{EB+MCF-EV123.h => eb_cpu5282.h} (97%) diff --git a/MAINTAINERS b/MAINTAINERS index 708ded7..ace42de 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1022,6 +1022,10 @@ Matthias Fuchs <matthias.fuchs(a)esd-electronics.com> TASREG MCF5249 +Jens Scharsig <esw(a)bus-elektronik.de> + + eb_cpu5282 mfc5282 + TsiChung Liew <Tsi-Chung.Liew(a)freescale.com> M52277EVB mcf5227x diff --git a/board/BuS/EB+MCF-EV123/Makefile b/board/BuS/eb_cpu5282/Makefile similarity index 100% rename from board/BuS/EB+MCF-EV123/Makefile rename to board/BuS/eb_cpu5282/Makefile diff --git a/board/BuS/EB+MCF-EV123/cfm_flash.c b/board/BuS/eb_cpu5282/cfm_flash.c similarity index 100% rename from board/BuS/EB+MCF-EV123/cfm_flash.c rename to board/BuS/eb_cpu5282/cfm_flash.c diff --git a/board/BuS/EB+MCF-EV123/cfm_flash.h b/board/BuS/eb_cpu5282/cfm_flash.h similarity index 100% rename from board/BuS/EB+MCF-EV123/cfm_flash.h rename to board/BuS/eb_cpu5282/cfm_flash.h diff --git a/board/BuS/EB+MCF-EV123/config.mk b/board/BuS/eb_cpu5282/config.mk similarity index 100% rename from board/BuS/EB+MCF-EV123/config.mk rename to board/BuS/eb_cpu5282/config.mk diff --git a/board/BuS/EB+MCF-EV123/EB+MCF-EV123.c b/board/BuS/eb_cpu5282/eb_cpu5282.c similarity index 100% rename from board/BuS/EB+MCF-EV123/EB+MCF-EV123.c rename to board/BuS/eb_cpu5282/eb_cpu5282.c diff --git a/board/BuS/EB+MCF-EV123/flash.c b/board/BuS/eb_cpu5282/flash.c similarity index 100% rename from board/BuS/EB+MCF-EV123/flash.c rename to board/BuS/eb_cpu5282/flash.c diff --git a/board/BuS/EB+MCF-EV123/u-boot.lds b/board/BuS/eb_cpu5282/u-boot.lds similarity index 100% rename from board/BuS/EB+MCF-EV123/u-boot.lds rename to board/BuS/eb_cpu5282/u-boot.lds diff --git a/boards.cfg b/boards.cfg index 3cf75c3..e510406 100644 --- a/boards.cfg +++ b/boards.cfg @@ -304,8 +304,8 @@ M5235EVB m68k mcf523x m5235evb freesca M5235EVB_Flash32 m68k mcf523x m5235evb freescale - M5235EVB:NORFLASH_PS32BIT,SYS_TEXT_BASE=0xFFC00000 cobra5272 m68k mcf52x2 cobra5272 - idmr m68k mcf52x2 -EB-MCF-EV123 m68k mcf52x2 EB+MCF-EV123 BuS - EB+MCF-EV123:SYS_TEXT_BASE=0xFFE00000 -EB-MCF-EV123_internal m68k mcf52x2 EB+MCF-EV123 BuS - EB+MCF-EV123:SYS_TEXT_BASE=0xF0000000 +eb_cpu5282 m68k mcf52x2 eb_cpu5282 BuS - eb_cpu5282:SYS_TEXT_BASE=0xFFE00000 +eb_cpu5282_internal m68k mcf52x2 eb_cpu5282 BuS - eb_cpu5282:SYS_TEXT_BASE=0xF0000000 TASREG m68k mcf52x2 tasreg esd M5208EVBE m68k mcf52x2 m5208evbe freescale M5249EVB m68k mcf52x2 m5249evb freescale diff --git a/include/configs/EB+MCF-EV123.h b/include/configs/eb_cpu5282.h similarity index 97% rename from include/configs/EB+MCF-EV123.h rename to include/configs/eb_cpu5282.h index 346b49c..ef9849d 100644 --- a/include/configs/EB+MCF-EV123.h +++ b/include/configs/eb_cpu5282.h @@ -1,5 +1,5 @@ /* - * Configuation settings for the BuS EB+MCF-EV123 boards. + * Configuation settings for the BuS EB+CPU5283 boards (aka EB+MCF-EV123) * * (C) Copyright 2005-2009 BuS Elektronik GmbH & Co.KG <esw(a)bus-elektonik.de> * @@ -22,8 +22,8 @@ * MA 02111-1307 USA */ -#ifndef _CONFIG_EB_MCF_EV123_H_ -#define _CONFIG_EB_MCF_EV123_H_ +#ifndef _CONFIG_EB_CPU5282_H_ +#define _CONFIG_EB_CPU5282_H_ #undef CONFIG_SYS_HALT_BEFOR_RAM_JUMP @@ -33,7 +33,6 @@ #define CONFIG_MCF52x2 /* define processor family */ #define CONFIG_M5282 /* define processor type */ -#define CONFIG_EB_MCF_EV123 #define CONFIG_MISC_INIT_R @@ -92,7 +91,7 @@ #define CONFIG_BOOTDELAY 5 #define CONFIG_SYS_HUSH_PARSER #define CONFIG_SYS_PROMPT_HUSH_PS2 "> " -#define CONFIG_SYS_PROMPT "\nEV123 U-Boot> " +#define CONFIG_SYS_PROMPT "\nEB+CPU5282> " #define CONFIG_SYS_LONGHELP 1 #if defined(CONFIG_CMD_KGDB) -- 1.7.3.4

2 1

← Newer
1
...
4
5
6
7
8
9
10
...
51
Older →

Jump to page: