yaffs-ecoscentric: yaffs

annotate yaffs_fs.c @ 219:472c51d85ef1

Fix compilation on Linux 2.6.26, fix compilation warnings

author	charles
date	Wed, 23 Jul 2008 04:35:12 +0100
parents	6dbe40ae9e54
children	16f50fb54fc0

rev	line source
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1 /*
174 7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	2 * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	3 *
174 7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	4 * Copyright (C) 2002-2007 Aleph One Ltd.
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	5 * for Toby Churchill Ltd and Brightstar Engineering
ddfefbbf40d3 * empty log message * charles parents: diff changeset	6 *
ddfefbbf40d3 * empty log message * charles parents: diff changeset	7 * Created by Charles Manning <charles@aleph1.co.uk>
174 7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	8 * Acknowledgements:
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	9 * Luc van OostenRyck for numerous patches.
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	10 * Nick Bane for numerous patches.
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	11 * Nick Bane for 2.5/2.6 integration.
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	12 * Andras Toth for mknod rdev issue.
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	13 * Michael Fischer for finding the problem with inode inconsistency.
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	14 * Some code bodily lifted from JFFS
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	15 *
ddfefbbf40d3 * empty log message * charles parents: diff changeset	16 * This program is free software; you can redistribute it and/or modify
ddfefbbf40d3 * empty log message * charles parents: diff changeset	17 * it under the terms of the GNU General Public License version 2 as
ddfefbbf40d3 * empty log message * charles parents: diff changeset	18 * published by the Free Software Foundation.
174 7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	19 */
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	20
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	21 /*
7d11ae6795e4 normalise licence headers and attributions wookey parents: 172 diff changeset	22 *
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	23 * This is the file system front-end to YAFFS that hooks it up to
ddfefbbf40d3 * empty log message * charles parents: diff changeset	24 * the VFS.
ddfefbbf40d3 * empty log message * charles parents: diff changeset	25 *
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	26 * Special notes:
78 222238621f18 lindent marty parents: 72 diff changeset	27 * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with
222238621f18 lindent marty parents: 72 diff changeset	28 * this superblock
222238621f18 lindent marty parents: 72 diff changeset	29 * >> 2.6: sb->s_fs_info points to the yaffs_Device associated with this
222238621f18 lindent marty parents: 72 diff changeset	30 * superblock
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	31 * >> inode->u.generic_ip points to the associated yaffs_Object.
ddfefbbf40d3 * empty log message * charles parents: diff changeset	32 */
ddfefbbf40d3 * empty log message * charles parents: diff changeset	33
78 222238621f18 lindent marty parents: 72 diff changeset	34 const char *yaffs_fs_c_version =
222238621f18 lindent marty parents: 72 diff changeset	35 "$Id$";
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	36 extern const char *yaffs_guts_c_version;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	37
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	38 #include <linux/version.h>
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	39 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	40 #include <linux/config.h>
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	41 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	42 #include <linux/kernel.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	43 #include <linux/module.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	44 #include <linux/slab.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	45 #include <linux/init.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	46 #include <linux/fs.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	47 #include <linux/proc_fs.h>
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	48 #include <linux/smp_lock.h>
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	49 #include <linux/pagemap.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	50 #include <linux/mtd/mtd.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	51 #include <linux/interrupt.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	52 #include <linux/string.h>
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	53 #include <linux/ctype.h>
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	54
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	55 #include "asm/div64.h"
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	56
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	57 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
ddfefbbf40d3 * empty log message * charles parents: diff changeset	58
ddfefbbf40d3 * empty log message * charles parents: diff changeset	59 #include <linux/statfs.h> /* Added NCB 15-8-2003 */
ddfefbbf40d3 * empty log message * charles parents: diff changeset	60 #include <asm/statfs.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	61 #define UnlockPage(p) unlock_page(p)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	62 #define Page_Uptodate(page) test_bit(PG_uptodate, &(page)->flags)
78 222238621f18 lindent marty parents: 72 diff changeset	63
222238621f18 lindent marty parents: 72 diff changeset	64 /* FIXME: use sb->s_id instead ? */
222238621f18 lindent marty parents: 72 diff changeset	65 #define yaffs_devname(sb, buf) bdevname(sb->s_bdev, buf)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	66
ddfefbbf40d3 * empty log message * charles parents: diff changeset	67 #else
ddfefbbf40d3 * empty log message * charles parents: diff changeset	68
ddfefbbf40d3 * empty log message * charles parents: diff changeset	69 #include <linux/locks.h>
39 48513a2b5762 Fix devname which was faked by always using "(unavailable)". luc parents: 38 diff changeset	70 #define BDEVNAME_SIZE 0
48513a2b5762 Fix devname which was faked by always using "(unavailable)". luc parents: 38 diff changeset	71 #define yaffs_devname(sb, buf) kdevname(sb->s_dev)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	72
143 5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	73 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	74 /* added NCB 26/5/2006 for 2.4.25-vrs2-tcl1 kernel */
5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	75 #define __user
5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	76 #endif
5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	77
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	78 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	79
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	80 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,26))
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	81 #define YPROC_ROOT &proc_root
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	82 #else
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	83 #define YPROC_ROOT NULL
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	84 #endif
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	85
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	86 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	87 #define WRITE_SIZE_STR "writesize"
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	88 #define WRITE_SIZE(mtd) (mtd)->writesize
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	89 #else
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	90 #define WRITE_SIZE_STR "oobblock"
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	91 #define WRITE_SIZE(mtd) (mtd)->oobblock
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	92 #endif
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	93
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	94 #include <asm/uaccess.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	95
ddfefbbf40d3 * empty log message * charles parents: diff changeset	96 #include "yportenv.h"
ddfefbbf40d3 * empty log message * charles parents: diff changeset	97 #include "yaffs_guts.h"
ddfefbbf40d3 * empty log message * charles parents: diff changeset	98
ddfefbbf40d3 * empty log message * charles parents: diff changeset	99 #include <linux/mtd/mtd.h>
ddfefbbf40d3 * empty log message * charles parents: diff changeset	100 #include "yaffs_mtdif.h"
185 fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	101 #include "yaffs_mtdif1.h"
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	102 #include "yaffs_mtdif2.h"
ddfefbbf40d3 * empty log message * charles parents: diff changeset	103
185 fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	104 unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS;
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	105 unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS;
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	106
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	107 /* Module Parameters */
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	108 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	109 module_param(yaffs_traceMask,uint,0644);
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	110 module_param(yaffs_wr_attempts,uint,0644);
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	111 #else
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	112 MODULE_PARM(yaffs_traceMask,"i");
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	113 MODULE_PARM(yaffs_wr_attempts,"i");
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	114 #endif
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	115
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	116 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,25))
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	117 /* use iget and read_inode */
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	118 #define Y_IGET(sb,inum) iget((sb),(inum))
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	119 static void yaffs_read_inode(struct inode *inode);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	120
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	121 #else
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	122 /* Call local equivalent */
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	123 #define YAFFS_USE_OWN_IGET
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	124 #define Y_IGET(sb,inum) yaffs_iget((sb),(inum))
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	125
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	126 static struct inode * yaffs_iget(struct super_block *sb, unsigned long ino);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	127 #endif
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	128
78 222238621f18 lindent marty parents: 72 diff changeset	129 /#define T(x) printk x /
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	130
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	131 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	132 #define yaffs_InodeToObjectLV(iptr) (iptr)->i_private
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	133 #else
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	134 #define yaffs_InodeToObjectLV(iptr) (iptr)->u.generic_ip
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	135 #endif
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	136
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	137 #define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr)))
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	138 #define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	139
ddfefbbf40d3 * empty log message * charles parents: diff changeset	140 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
ddfefbbf40d3 * empty log message * charles parents: diff changeset	141 #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->s_fs_info)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	142 #else
ddfefbbf40d3 * empty log message * charles parents: diff changeset	143 #define yaffs_SuperToDevice(sb) ((yaffs_Device *)sb->u.generic_sbp)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	144 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	145
ddfefbbf40d3 * empty log message * charles parents: diff changeset	146 static void yaffs_put_super(struct super_block *sb);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	147
78 222238621f18 lindent marty parents: 72 diff changeset	148 static ssize_t yaffs_file_write(struct file f, const char buf, size_t n,
222238621f18 lindent marty parents: 72 diff changeset	149 loff_t * pos);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	150
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	151 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	152 static int yaffs_file_flush(struct file *file, fl_owner_t id);
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	153 #else
78 222238621f18 lindent marty parents: 72 diff changeset	154 static int yaffs_file_flush(struct file *file);
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	155 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	156
78 222238621f18 lindent marty parents: 72 diff changeset	157 static int yaffs_sync_object(struct file file, struct dentry dentry,
222238621f18 lindent marty parents: 72 diff changeset	158 int datasync);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	159
ddfefbbf40d3 * empty log message * charles parents: diff changeset	160 static int yaffs_readdir(struct file f, void dirent, filldir_t filldir);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	161
ddfefbbf40d3 * empty log message * charles parents: diff changeset	162 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	163 static int yaffs_create(struct inode dir, struct dentry dentry, int mode,
222238621f18 lindent marty parents: 72 diff changeset	164 struct nameidata *n);
222238621f18 lindent marty parents: 72 diff changeset	165 static struct dentry yaffs_lookup(struct inode dir, struct dentry *dentry,
222238621f18 lindent marty parents: 72 diff changeset	166 struct nameidata *n);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	167 #else
ddfefbbf40d3 * empty log message * charles parents: diff changeset	168 static int yaffs_create(struct inode dir, struct dentry dentry, int mode);
78 222238621f18 lindent marty parents: 72 diff changeset	169 static struct dentry yaffs_lookup(struct inode dir, struct dentry *dentry);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	170 #endif
78 222238621f18 lindent marty parents: 72 diff changeset	171 static int yaffs_link(struct dentry old_dentry, struct inode dir,
222238621f18 lindent marty parents: 72 diff changeset	172 struct dentry *dentry);
222238621f18 lindent marty parents: 72 diff changeset	173 static int yaffs_unlink(struct inode dir, struct dentry dentry);
222238621f18 lindent marty parents: 72 diff changeset	174 static int yaffs_symlink(struct inode dir, struct dentry dentry,
222238621f18 lindent marty parents: 72 diff changeset	175 const char *symname);
222238621f18 lindent marty parents: 72 diff changeset	176 static int yaffs_mkdir(struct inode dir, struct dentry dentry, int mode);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	177
ddfefbbf40d3 * empty log message * charles parents: diff changeset	178 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	179 static int yaffs_mknod(struct inode dir, struct dentry dentry, int mode,
222238621f18 lindent marty parents: 72 diff changeset	180 dev_t dev);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	181 #else
78 222238621f18 lindent marty parents: 72 diff changeset	182 static int yaffs_mknod(struct inode dir, struct dentry dentry, int mode,
222238621f18 lindent marty parents: 72 diff changeset	183 int dev);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	184 #endif
78 222238621f18 lindent marty parents: 72 diff changeset	185 static int yaffs_rename(struct inode old_dir, struct dentry old_dentry,
222238621f18 lindent marty parents: 72 diff changeset	186 struct inode new_dir, struct dentry new_dentry);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	187 static int yaffs_setattr(struct dentry dentry, struct iattr attr);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	188
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	189 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	190 static int yaffs_sync_fs(struct super_block *sb, int wait);
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	191 static void yaffs_write_super(struct super_block *sb);
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	192 #else
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	193 static int yaffs_sync_fs(struct super_block *sb);
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	194 static int yaffs_write_super(struct super_block *sb);
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	195 #endif
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	196
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	197 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	198 static int yaffs_statfs(struct dentry dentry, struct kstatfs buf);
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	199 #elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	200 static int yaffs_statfs(struct super_block sb, struct kstatfs buf);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	201 #else
ddfefbbf40d3 * empty log message * charles parents: diff changeset	202 static int yaffs_statfs(struct super_block sb, struct statfs buf);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	203 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	204
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	205 #ifdef YAFFS_HAS_PUT_INODE
78 222238621f18 lindent marty parents: 72 diff changeset	206 static void yaffs_put_inode(struct inode *inode);
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	207 #endif
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	208
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	209 static void yaffs_delete_inode(struct inode *);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	210 static void yaffs_clear_inode(struct inode *);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	211
78 222238621f18 lindent marty parents: 72 diff changeset	212 static int yaffs_readpage(struct file file, struct page page);
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	213 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	214 static int yaffs_writepage(struct page page, struct writeback_control wbc);
510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	215 #else
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	216 static int yaffs_writepage(struct page *page);
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	217 #endif
78 222238621f18 lindent marty parents: 72 diff changeset	218 static int yaffs_prepare_write(struct file f, struct page pg,
222238621f18 lindent marty parents: 72 diff changeset	219 unsigned offset, unsigned to);
222238621f18 lindent marty parents: 72 diff changeset	220 static int yaffs_commit_write(struct file f, struct page pg, unsigned offset,
222238621f18 lindent marty parents: 72 diff changeset	221 unsigned to);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	222
78 222238621f18 lindent marty parents: 72 diff changeset	223 static int yaffs_readlink(struct dentry dentry, char __user buffer,
222238621f18 lindent marty parents: 72 diff changeset	224 int buflen);
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	225 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	226 static void yaffs_follow_link(struct dentry dentry, struct nameidata *nd);
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	227 #else
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	228 static int yaffs_follow_link(struct dentry dentry, struct nameidata nd);
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	229 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	230
ddfefbbf40d3 * empty log message * charles parents: diff changeset	231 static struct address_space_operations yaffs_file_address_operations = {
78 222238621f18 lindent marty parents: 72 diff changeset	232 .readpage = yaffs_readpage,
222238621f18 lindent marty parents: 72 diff changeset	233 .writepage = yaffs_writepage,
222238621f18 lindent marty parents: 72 diff changeset	234 .prepare_write = yaffs_prepare_write,
222238621f18 lindent marty parents: 72 diff changeset	235 .commit_write = yaffs_commit_write,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	236 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	237
195 d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	238 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	239 static struct file_operations yaffs_file_operations = {
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	240 .read = do_sync_read,
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	241 .write = do_sync_write,
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	242 .aio_read = generic_file_aio_read,
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	243 .aio_write = generic_file_aio_write,
195 d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	244 .mmap = generic_file_mmap,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	245 .flush = yaffs_file_flush,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	246 .fsync = yaffs_sync_object,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	247 .splice_read = generic_file_splice_read,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	248 .splice_write = generic_file_splice_write,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	249 };
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	250
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	251 #elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	252
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	253 static struct file_operations yaffs_file_operations = {
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	254 .read = do_sync_read,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	255 .write = do_sync_write,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	256 .aio_read = generic_file_aio_read,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	257 .aio_write = generic_file_aio_write,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	258 .mmap = generic_file_mmap,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	259 .flush = yaffs_file_flush,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	260 .fsync = yaffs_sync_object,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	261 .sendfile = generic_file_sendfile,
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	262 };
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	263
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	264 #else
195 d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	265
d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	266 static struct file_operations yaffs_file_operations = {
78 222238621f18 lindent marty parents: 72 diff changeset	267 .read = generic_file_read,
222238621f18 lindent marty parents: 72 diff changeset	268 .write = generic_file_write,
222238621f18 lindent marty parents: 72 diff changeset	269 .mmap = generic_file_mmap,
222238621f18 lindent marty parents: 72 diff changeset	270 .flush = yaffs_file_flush,
222238621f18 lindent marty parents: 72 diff changeset	271 .fsync = yaffs_sync_object,
115 448c45ce46b0 Add generic sendfile method for yaffs2, also thereby allowing loopback mount. tpoynor parents: 112 diff changeset	272 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
448c45ce46b0 Add generic sendfile method for yaffs2, also thereby allowing loopback mount. tpoynor parents: 112 diff changeset	273 .sendfile = generic_file_sendfile,
448c45ce46b0 Add generic sendfile method for yaffs2, also thereby allowing loopback mount. tpoynor parents: 112 diff changeset	274 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	275 };
195 d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	276 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	277
ddfefbbf40d3 * empty log message * charles parents: diff changeset	278 static struct inode_operations yaffs_file_inode_operations = {
78 222238621f18 lindent marty parents: 72 diff changeset	279 .setattr = yaffs_setattr,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	280 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	281
78 222238621f18 lindent marty parents: 72 diff changeset	282 static struct inode_operations yaffs_symlink_inode_operations = {
222238621f18 lindent marty parents: 72 diff changeset	283 .readlink = yaffs_readlink,
222238621f18 lindent marty parents: 72 diff changeset	284 .follow_link = yaffs_follow_link,
222238621f18 lindent marty parents: 72 diff changeset	285 .setattr = yaffs_setattr,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	286 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	287
ddfefbbf40d3 * empty log message * charles parents: diff changeset	288 static struct inode_operations yaffs_dir_inode_operations = {
78 222238621f18 lindent marty parents: 72 diff changeset	289 .create = yaffs_create,
222238621f18 lindent marty parents: 72 diff changeset	290 .lookup = yaffs_lookup,
222238621f18 lindent marty parents: 72 diff changeset	291 .link = yaffs_link,
222238621f18 lindent marty parents: 72 diff changeset	292 .unlink = yaffs_unlink,
222238621f18 lindent marty parents: 72 diff changeset	293 .symlink = yaffs_symlink,
222238621f18 lindent marty parents: 72 diff changeset	294 .mkdir = yaffs_mkdir,
222238621f18 lindent marty parents: 72 diff changeset	295 .rmdir = yaffs_unlink,
222238621f18 lindent marty parents: 72 diff changeset	296 .mknod = yaffs_mknod,
222238621f18 lindent marty parents: 72 diff changeset	297 .rename = yaffs_rename,
222238621f18 lindent marty parents: 72 diff changeset	298 .setattr = yaffs_setattr,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	299 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	300
ddfefbbf40d3 * empty log message * charles parents: diff changeset	301 static struct file_operations yaffs_dir_operations = {
78 222238621f18 lindent marty parents: 72 diff changeset	302 .read = generic_read_dir,
222238621f18 lindent marty parents: 72 diff changeset	303 .readdir = yaffs_readdir,
222238621f18 lindent marty parents: 72 diff changeset	304 .fsync = yaffs_sync_object,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	305 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	306
ddfefbbf40d3 * empty log message * charles parents: diff changeset	307 static struct super_operations yaffs_super_ops = {
78 222238621f18 lindent marty parents: 72 diff changeset	308 .statfs = yaffs_statfs,
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	309
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	310 #ifndef YAFFS_USE_OWN_IGET
78 222238621f18 lindent marty parents: 72 diff changeset	311 .read_inode = yaffs_read_inode,
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	312 #endif
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	313 #ifdef YAFFS_HAS_PUT_INODE
78 222238621f18 lindent marty parents: 72 diff changeset	314 .put_inode = yaffs_put_inode,
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	315 #endif
78 222238621f18 lindent marty parents: 72 diff changeset	316 .put_super = yaffs_put_super,
222238621f18 lindent marty parents: 72 diff changeset	317 .delete_inode = yaffs_delete_inode,
222238621f18 lindent marty parents: 72 diff changeset	318 .clear_inode = yaffs_clear_inode,
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	319 .sync_fs = yaffs_sync_fs,
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	320 .write_super = yaffs_write_super,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	321 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	322
78 222238621f18 lindent marty parents: 72 diff changeset	323 static void yaffs_GrossLock(yaffs_Device * dev)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	324 {
78 222238621f18 lindent marty parents: 72 diff changeset	325 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs locking\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	326
ddfefbbf40d3 * empty log message * charles parents: diff changeset	327 down(&dev->grossLock);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	328 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	329
78 222238621f18 lindent marty parents: 72 diff changeset	330 static void yaffs_GrossUnlock(yaffs_Device * dev)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	331 {
78 222238621f18 lindent marty parents: 72 diff changeset	332 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs unlocking\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	333 up(&dev->grossLock);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	334
ddfefbbf40d3 * empty log message * charles parents: diff changeset	335 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	336
78 222238621f18 lindent marty parents: 72 diff changeset	337 static int yaffs_readlink(struct dentry dentry, char __user buffer,
222238621f18 lindent marty parents: 72 diff changeset	338 int buflen)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	339 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	340 unsigned char *alias;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	341 int ret;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	342
ddfefbbf40d3 * empty log message * charles parents: diff changeset	343 yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	344
78 222238621f18 lindent marty parents: 72 diff changeset	345 yaffs_GrossLock(dev);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	346
ddfefbbf40d3 * empty log message * charles parents: diff changeset	347 alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
78 222238621f18 lindent marty parents: 72 diff changeset	348
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	349 yaffs_GrossUnlock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	350
222238621f18 lindent marty parents: 72 diff changeset	351 if (!alias)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	352 return -ENOMEM;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	353
ddfefbbf40d3 * empty log message * charles parents: diff changeset	354 ret = vfs_readlink(dentry, buffer, buflen, alias);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	355 kfree(alias);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	356 return ret;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	357 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	358
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	359 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	360 static void yaffs_follow_link(struct dentry dentry, struct nameidata *nd)
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	361 #else
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	362 static int yaffs_follow_link(struct dentry dentry, struct nameidata nd)
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	363 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	364 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	365 unsigned char *alias;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	366 int ret;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	367 yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	368
ddfefbbf40d3 * empty log message * charles parents: diff changeset	369 yaffs_GrossLock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	370
ddfefbbf40d3 * empty log message * charles parents: diff changeset	371 alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
78 222238621f18 lindent marty parents: 72 diff changeset	372
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	373 yaffs_GrossUnlock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	374
222238621f18 lindent marty parents: 72 diff changeset	375 if (!alias)
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	376 {
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	377 ret = -ENOMEM;
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	378 goto out;
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	379 }
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	380
78 222238621f18 lindent marty parents: 72 diff changeset	381 ret = vfs_follow_link(nd, alias);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	382 kfree(alias);
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	383 out:
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	384 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	385 return ERR_PTR (ret);
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	386 #else
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	387 return ret;
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	388 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	389 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	390
78 222238621f18 lindent marty parents: 72 diff changeset	391 struct inode yaffs_get_inode(struct super_block sb, int mode, int dev,
222238621f18 lindent marty parents: 72 diff changeset	392 yaffs_Object * obj);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	393
ddfefbbf40d3 * empty log message * charles parents: diff changeset	394 /*
ddfefbbf40d3 * empty log message * charles parents: diff changeset	395 * Lookup is used to find objects in the fs
ddfefbbf40d3 * empty log message * charles parents: diff changeset	396 */
ddfefbbf40d3 * empty log message * charles parents: diff changeset	397 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
ddfefbbf40d3 * empty log message * charles parents: diff changeset	398
78 222238621f18 lindent marty parents: 72 diff changeset	399 static struct dentry yaffs_lookup(struct inode dir, struct dentry *dentry,
222238621f18 lindent marty parents: 72 diff changeset	400 struct nameidata *n)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	401 #else
78 222238621f18 lindent marty parents: 72 diff changeset	402 static struct dentry yaffs_lookup(struct inode dir, struct dentry *dentry)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	403 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	404 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	405 yaffs_Object *obj;
78 222238621f18 lindent marty parents: 72 diff changeset	406 struct inode inode = NULL; / NCB 2.5/2.6 needs NULL here */
222238621f18 lindent marty parents: 72 diff changeset	407
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	408 yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	409
ddfefbbf40d3 * empty log message * charles parents: diff changeset	410 yaffs_GrossLock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	411
78 222238621f18 lindent marty parents: 72 diff changeset	412 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	413 (KERN_DEBUG "yaffs_lookup for %d:%s\n",
222238621f18 lindent marty parents: 72 diff changeset	414 yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
222238621f18 lindent marty parents: 72 diff changeset	415
222238621f18 lindent marty parents: 72 diff changeset	416 obj =
222238621f18 lindent marty parents: 72 diff changeset	417 yaffs_FindObjectByName(yaffs_InodeToObject(dir),
222238621f18 lindent marty parents: 72 diff changeset	418 dentry->d_name.name);
222238621f18 lindent marty parents: 72 diff changeset	419
222238621f18 lindent marty parents: 72 diff changeset	420 obj = yaffs_GetEquivalentObject(obj); /* in case it was a hardlink */
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	421
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	422 /* Can't hold gross lock when calling yaffs_get_inode() */
1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	423 yaffs_GrossUnlock(dev);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	424
78 222238621f18 lindent marty parents: 72 diff changeset	425 if (obj) {
222238621f18 lindent marty parents: 72 diff changeset	426 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	427 (KERN_DEBUG "yaffs_lookup found %d\n", obj->objectId));
222238621f18 lindent marty parents: 72 diff changeset	428
222238621f18 lindent marty parents: 72 diff changeset	429 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
222238621f18 lindent marty parents: 72 diff changeset	430
222238621f18 lindent marty parents: 72 diff changeset	431 if (inode) {
222238621f18 lindent marty parents: 72 diff changeset	432 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	433 (KERN_DEBUG "yaffs_loookup dentry \n"));
222238621f18 lindent marty parents: 72 diff changeset	434 /* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
222238621f18 lindent marty parents: 72 diff changeset	435 * d_add even if NULL inode */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	436 #if 0
78 222238621f18 lindent marty parents: 72 diff changeset	437 /dget(dentry); // try to solve directory bug /
222238621f18 lindent marty parents: 72 diff changeset	438 d_add(dentry, inode);
222238621f18 lindent marty parents: 72 diff changeset	439
222238621f18 lindent marty parents: 72 diff changeset	440 /* return dentry; */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	441 return NULL;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	442 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	443 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	444
78 222238621f18 lindent marty parents: 72 diff changeset	445 } else {
222238621f18 lindent marty parents: 72 diff changeset	446 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_lookup not found\n"));
222238621f18 lindent marty parents: 72 diff changeset	447
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	448 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	449
78 222238621f18 lindent marty parents: 72 diff changeset	450 /* added NCB for 2.5/6 compatability - forces add even if inode is
222238621f18 lindent marty parents: 72 diff changeset	451 * NULL which creates dentry hash */
222238621f18 lindent marty parents: 72 diff changeset	452 d_add(dentry, inode);
222238621f18 lindent marty parents: 72 diff changeset	453
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	454 return NULL;
78 222238621f18 lindent marty parents: 72 diff changeset	455 /* return (ERR_PTR(-EIO)); */
222238621f18 lindent marty parents: 72 diff changeset	456
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	457 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	458
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	459
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	460 #ifdef YAFFS_HAS_PUT_INODE
472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	461
78 222238621f18 lindent marty parents: 72 diff changeset	462 /* For now put inode is just for debugging
222238621f18 lindent marty parents: 72 diff changeset	463 * Put inode is called when the inode structure is put.
222238621f18 lindent marty parents: 72 diff changeset	464 */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	465 static void yaffs_put_inode(struct inode *inode)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	466 {
78 222238621f18 lindent marty parents: 72 diff changeset	467 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	468 ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
222238621f18 lindent marty parents: 72 diff changeset	469 atomic_read(&inode->i_count)));
222238621f18 lindent marty parents: 72 diff changeset	470
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	471 }
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	472 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	473
78 222238621f18 lindent marty parents: 72 diff changeset	474 /* clear is called to tell the fs to release any per-inode data it holds */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	475 static void yaffs_clear_inode(struct inode *inode)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	476 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	477 yaffs_Object *obj;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	478 yaffs_Device *dev;
78 222238621f18 lindent marty parents: 72 diff changeset	479
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	480 obj = yaffs_InodeToObject(inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	481
78 222238621f18 lindent marty parents: 72 diff changeset	482 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	483 ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
222238621f18 lindent marty parents: 72 diff changeset	484 atomic_read(&inode->i_count),
222238621f18 lindent marty parents: 72 diff changeset	485 obj ? "object exists" : "null object"));
222238621f18 lindent marty parents: 72 diff changeset	486
222238621f18 lindent marty parents: 72 diff changeset	487 if (obj) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	488 dev = obj->myDev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	489 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	490
222238621f18 lindent marty parents: 72 diff changeset	491 /* Clear the association between the inode and
222238621f18 lindent marty parents: 72 diff changeset	492 * the yaffs_Object.
222238621f18 lindent marty parents: 72 diff changeset	493 */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	494 obj->myInode = NULL;
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	495 yaffs_InodeToObjectLV(inode) = NULL;
78 222238621f18 lindent marty parents: 72 diff changeset	496
222238621f18 lindent marty parents: 72 diff changeset	497 /* If the object freeing was deferred, then the real
222238621f18 lindent marty parents: 72 diff changeset	498 * free happens now.
222238621f18 lindent marty parents: 72 diff changeset	499 * This should fix the inode inconsistency problem.
222238621f18 lindent marty parents: 72 diff changeset	500 */
222238621f18 lindent marty parents: 72 diff changeset	501
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	502 yaffs_HandleDeferedFree(obj);
78 222238621f18 lindent marty parents: 72 diff changeset	503
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	504 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	505 }
78 222238621f18 lindent marty parents: 72 diff changeset	506
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	507 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	508
78 222238621f18 lindent marty parents: 72 diff changeset	509 /* delete is called when the link count is zero and the inode
222238621f18 lindent marty parents: 72 diff changeset	510 * is put (ie. nobody wants to know about it anymore, time to
222238621f18 lindent marty parents: 72 diff changeset	511 * delete the file).
222238621f18 lindent marty parents: 72 diff changeset	512 * NB Must call clear_inode()
222238621f18 lindent marty parents: 72 diff changeset	513 */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	514 static void yaffs_delete_inode(struct inode *inode)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	515 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	516 yaffs_Object *obj = yaffs_InodeToObject(inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	517 yaffs_Device *dev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	518
78 222238621f18 lindent marty parents: 72 diff changeset	519 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	520 ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
222238621f18 lindent marty parents: 72 diff changeset	521 atomic_read(&inode->i_count),
222238621f18 lindent marty parents: 72 diff changeset	522 obj ? "object exists" : "null object"));
222238621f18 lindent marty parents: 72 diff changeset	523
222238621f18 lindent marty parents: 72 diff changeset	524 if (obj) {
222238621f18 lindent marty parents: 72 diff changeset	525 dev = obj->myDev;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	526 yaffs_GrossLock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	527 yaffs_DeleteFile(obj);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	528 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	529 }
102 0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	530 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	531 truncate_inode_pages (&inode->i_data, 0);
0e8b8a695278 Apply 2.6.14 patches from Andre charles parents: 98 diff changeset	532 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	533 clear_inode(inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	534 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	535
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	536 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	537 static int yaffs_file_flush(struct file *file, fl_owner_t id)
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	538 #else
78 222238621f18 lindent marty parents: 72 diff changeset	539 static int yaffs_file_flush(struct file *file)
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	540 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	541 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	542 yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry);
78 222238621f18 lindent marty parents: 72 diff changeset	543
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	544 yaffs_Device *dev = obj->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	545
222238621f18 lindent marty parents: 72 diff changeset	546 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	547 (KERN_DEBUG "yaffs_file_flush object %d (%s)\n", obj->objectId,
222238621f18 lindent marty parents: 72 diff changeset	548 obj->dirty ? "dirty" : "clean"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	549
ddfefbbf40d3 * empty log message * charles parents: diff changeset	550 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	551
222238621f18 lindent marty parents: 72 diff changeset	552 yaffs_FlushFile(obj, 1);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	553
ddfefbbf40d3 * empty log message * charles parents: diff changeset	554 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	555
78 222238621f18 lindent marty parents: 72 diff changeset	556 return 0;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	557 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	558
78 222238621f18 lindent marty parents: 72 diff changeset	559 static int yaffs_readpage_nolock(struct file f, struct page pg)
222238621f18 lindent marty parents: 72 diff changeset	560 {
222238621f18 lindent marty parents: 72 diff changeset	561 /* Lifted from jffs2 */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	562
ddfefbbf40d3 * empty log message * charles parents: diff changeset	563 yaffs_Object *obj;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	564 unsigned char *pg_buf;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	565 int ret;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	566
ddfefbbf40d3 * empty log message * charles parents: diff changeset	567 yaffs_Device *dev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	568
78 222238621f18 lindent marty parents: 72 diff changeset	569 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage at %08x, size %08x\n",
222238621f18 lindent marty parents: 72 diff changeset	570 (unsigned)(pg->index << PAGE_CACHE_SHIFT),
222238621f18 lindent marty parents: 72 diff changeset	571 (unsigned)PAGE_CACHE_SIZE));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	572
78 222238621f18 lindent marty parents: 72 diff changeset	573 obj = yaffs_DentryToObject(f->f_dentry);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	574
ddfefbbf40d3 * empty log message * charles parents: diff changeset	575 dev = obj->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	576
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	577 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	578 BUG_ON(!PageLocked(pg));
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	579 #else
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	580 if (!PageLocked(pg))
78 222238621f18 lindent marty parents: 72 diff changeset	581 PAGE_BUG(pg);
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	582 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	583
ddfefbbf40d3 * empty log message * charles parents: diff changeset	584 pg_buf = kmap(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	585 /* FIXME: Can kmap fail? */
ddfefbbf40d3 * empty log message * charles parents: diff changeset	586
ddfefbbf40d3 * empty log message * charles parents: diff changeset	587 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	588
222238621f18 lindent marty parents: 72 diff changeset	589 ret =
222238621f18 lindent marty parents: 72 diff changeset	590 yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT,
222238621f18 lindent marty parents: 72 diff changeset	591 PAGE_CACHE_SIZE);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	592
ddfefbbf40d3 * empty log message * charles parents: diff changeset	593 yaffs_GrossUnlock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	594
222238621f18 lindent marty parents: 72 diff changeset	595 if (ret >= 0)
222238621f18 lindent marty parents: 72 diff changeset	596 ret = 0;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	597
ddfefbbf40d3 * empty log message * charles parents: diff changeset	598 if (ret) {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	599 ClearPageUptodate(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	600 SetPageError(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	601 } else {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	602 SetPageUptodate(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	603 ClearPageError(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	604 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	605
ddfefbbf40d3 * empty log message * charles parents: diff changeset	606 flush_dcache_page(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	607 kunmap(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	608
78 222238621f18 lindent marty parents: 72 diff changeset	609 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage done\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	610 return ret;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	611 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	612
ddfefbbf40d3 * empty log message * charles parents: diff changeset	613 static int yaffs_readpage_unlock(struct file f, struct page pg)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	614 {
78 222238621f18 lindent marty parents: 72 diff changeset	615 int ret = yaffs_readpage_nolock(f, pg);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	616 UnlockPage(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	617 return ret;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	618 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	619
78 222238621f18 lindent marty parents: 72 diff changeset	620 static int yaffs_readpage(struct file f, struct page pg)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	621 {
78 222238621f18 lindent marty parents: 72 diff changeset	622 return yaffs_readpage_unlock(f, pg);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	623 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	624
78 222238621f18 lindent marty parents: 72 diff changeset	625 /* writepage inspired by/stolen from smbfs */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	626
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	627 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	628 static int yaffs_writepage(struct page page, struct writeback_control wbc)
510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	629 #else
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	630 static int yaffs_writepage(struct page *page)
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	631 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	632 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	633 struct address_space *mapping = page->mapping;
78 222238621f18 lindent marty parents: 72 diff changeset	634 loff_t offset = (loff_t) page->index << PAGE_CACHE_SHIFT;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	635 struct inode *inode;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	636 unsigned long end_index;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	637 char *buffer;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	638 yaffs_Object *obj;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	639 int nWritten = 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	640 unsigned nBytes;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	641
ddfefbbf40d3 * empty log message * charles parents: diff changeset	642 if (!mapping)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	643 BUG();
ddfefbbf40d3 * empty log message * charles parents: diff changeset	644 inode = mapping->host;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	645 if (!inode)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	646 BUG();
ddfefbbf40d3 * empty log message * charles parents: diff changeset	647
78 222238621f18 lindent marty parents: 72 diff changeset	648 if (offset > inode->i_size) {
222238621f18 lindent marty parents: 72 diff changeset	649 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	650 (KERN_DEBUG
222238621f18 lindent marty parents: 72 diff changeset	651 "yaffs_writepage at %08x, inode size = %08x!!!\n",
222238621f18 lindent marty parents: 72 diff changeset	652 (unsigned)(page->index << PAGE_CACHE_SHIFT),
222238621f18 lindent marty parents: 72 diff changeset	653 (unsigned)inode->i_size));
222238621f18 lindent marty parents: 72 diff changeset	654 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	655 (KERN_DEBUG " -> don't care!!\n"));
69 ea3ee1ec917a Fix an error in writepage when a file is extended. luc parents: 63 diff changeset	656 unlock_page(page);
ea3ee1ec917a Fix an error in writepage when a file is extended. luc parents: 63 diff changeset	657 return 0;
ea3ee1ec917a Fix an error in writepage when a file is extended. luc parents: 63 diff changeset	658 }
ea3ee1ec917a Fix an error in writepage when a file is extended. luc parents: 63 diff changeset	659
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	660 end_index = inode->i_size >> PAGE_CACHE_SHIFT;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	661
ddfefbbf40d3 * empty log message * charles parents: diff changeset	662 /* easy case */
78 222238621f18 lindent marty parents: 72 diff changeset	663 if (page->index < end_index) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	664 nBytes = PAGE_CACHE_SIZE;
78 222238621f18 lindent marty parents: 72 diff changeset	665 } else {
222238621f18 lindent marty parents: 72 diff changeset	666 nBytes = inode->i_size & (PAGE_CACHE_SIZE - 1);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	667 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	668
ddfefbbf40d3 * empty log message * charles parents: diff changeset	669 get_page(page);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	670
ddfefbbf40d3 * empty log message * charles parents: diff changeset	671 buffer = kmap(page);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	672
ddfefbbf40d3 * empty log message * charles parents: diff changeset	673 obj = yaffs_InodeToObject(inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	674 yaffs_GrossLock(obj->myDev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	675
78 222238621f18 lindent marty parents: 72 diff changeset	676 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	677 (KERN_DEBUG "yaffs_writepage at %08x, size %08x\n",
222238621f18 lindent marty parents: 72 diff changeset	678 (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
222238621f18 lindent marty parents: 72 diff changeset	679 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	680 (KERN_DEBUG "writepag0: obj = %05x, ino = %05x\n",
222238621f18 lindent marty parents: 72 diff changeset	681 (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	682
78 222238621f18 lindent marty parents: 72 diff changeset	683 nWritten =
222238621f18 lindent marty parents: 72 diff changeset	684 yaffs_WriteDataToFile(obj, buffer, page->index << PAGE_CACHE_SHIFT,
222238621f18 lindent marty parents: 72 diff changeset	685 nBytes, 0);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	686
78 222238621f18 lindent marty parents: 72 diff changeset	687 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	688 (KERN_DEBUG "writepag1: obj = %05x, ino = %05x\n",
222238621f18 lindent marty parents: 72 diff changeset	689 (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
69 ea3ee1ec917a Fix an error in writepage when a file is extended. luc parents: 63 diff changeset	690
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	691 yaffs_GrossUnlock(obj->myDev);
78 222238621f18 lindent marty parents: 72 diff changeset	692
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	693 kunmap(page);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	694 SetPageUptodate(page);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	695 UnlockPage(page);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	696 put_page(page);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	697
78 222238621f18 lindent marty parents: 72 diff changeset	698 return (nWritten == nBytes) ? 0 : -ENOSPC;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	699 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	700
78 222238621f18 lindent marty parents: 72 diff changeset	701 static int yaffs_prepare_write(struct file f, struct page pg,
222238621f18 lindent marty parents: 72 diff changeset	702 unsigned offset, unsigned to)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	703 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	704
78 222238621f18 lindent marty parents: 72 diff changeset	705 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_prepair_write\n"));
222238621f18 lindent marty parents: 72 diff changeset	706 if (!Page_Uptodate(pg) && (offset \|\| to < PAGE_CACHE_SIZE))
222238621f18 lindent marty parents: 72 diff changeset	707 return yaffs_readpage_nolock(f, pg);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	708
ddfefbbf40d3 * empty log message * charles parents: diff changeset	709 return 0;
78 222238621f18 lindent marty parents: 72 diff changeset	710
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	711 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	712
78 222238621f18 lindent marty parents: 72 diff changeset	713 static int yaffs_commit_write(struct file f, struct page pg, unsigned offset,
222238621f18 lindent marty parents: 72 diff changeset	714 unsigned to)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	715 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	716
ddfefbbf40d3 * empty log message * charles parents: diff changeset	717 void *addr = page_address(pg) + offset;
78 222238621f18 lindent marty parents: 72 diff changeset	718 loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	719 int nBytes = to - offset;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	720 int nWritten;
78 222238621f18 lindent marty parents: 72 diff changeset	721
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	722 unsigned spos = pos;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	723 unsigned saddr = (unsigned)addr;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	724
78 222238621f18 lindent marty parents: 72 diff changeset	725 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	726 (KERN_DEBUG "yaffs_commit_write addr %x pos %x nBytes %d\n", saddr,
222238621f18 lindent marty parents: 72 diff changeset	727 spos, nBytes));
222238621f18 lindent marty parents: 72 diff changeset	728
222238621f18 lindent marty parents: 72 diff changeset	729 nWritten = yaffs_file_write(f, addr, nBytes, &pos);
222238621f18 lindent marty parents: 72 diff changeset	730
222238621f18 lindent marty parents: 72 diff changeset	731 if (nWritten != nBytes) {
222238621f18 lindent marty parents: 72 diff changeset	732 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	733 (KERN_DEBUG
222238621f18 lindent marty parents: 72 diff changeset	734 "yaffs_commit_write not same size nWritten %d nBytes %d\n",
222238621f18 lindent marty parents: 72 diff changeset	735 nWritten, nBytes));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	736 SetPageError(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	737 ClearPageUptodate(pg);
78 222238621f18 lindent marty parents: 72 diff changeset	738 } else {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	739 SetPageUptodate(pg);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	740 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	741
78 222238621f18 lindent marty parents: 72 diff changeset	742 T(YAFFS_TRACE_OS,
97 a39f723d20f1 Patch from Todd Poyner (tpoynor@mvista.com) marty parents: 91 diff changeset	743 (KERN_DEBUG "yaffs_commit_write returning %d\n",
116 c110f6f02466 Handle partial writes more gracefully: return partial byte counts, return tpoynor parents: 115 diff changeset	744 nWritten == nBytes ? 0 : nWritten));
78 222238621f18 lindent marty parents: 72 diff changeset	745
116 c110f6f02466 Handle partial writes more gracefully: return partial byte counts, return tpoynor parents: 115 diff changeset	746 return nWritten == nBytes ? 0 : nWritten;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	747
ddfefbbf40d3 * empty log message * charles parents: diff changeset	748 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	749
78 222238621f18 lindent marty parents: 72 diff changeset	750 static void yaffs_FillInodeFromObject(struct inode inode, yaffs_Object obj)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	751 {
78 222238621f18 lindent marty parents: 72 diff changeset	752 if (inode && obj) {
145 7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	753
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	754
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	755 /* Check mode against the variant type and attempt to repair if broken. */
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	756 __u32 mode = obj->yst_mode;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	757 switch( obj->variantType ){
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	758 case YAFFS_OBJECT_TYPE_FILE :
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	759 if( ! S_ISREG(mode) ){
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	760 obj->yst_mode &= ~S_IFMT;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	761 obj->yst_mode \|= S_IFREG;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	762 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	763
145 7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	764 break;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	765 case YAFFS_OBJECT_TYPE_SYMLINK :
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	766 if( ! S_ISLNK(mode) ){
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	767 obj->yst_mode &= ~S_IFMT;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	768 obj->yst_mode \|= S_IFLNK;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	769 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	770
145 7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	771 break;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	772 case YAFFS_OBJECT_TYPE_DIRECTORY :
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	773 if( ! S_ISDIR(mode) ){
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	774 obj->yst_mode &= ~S_IFMT;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	775 obj->yst_mode \|= S_IFDIR;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	776 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	777
145 7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	778 break;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	779 case YAFFS_OBJECT_TYPE_UNKNOWN :
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	780 case YAFFS_OBJECT_TYPE_HARDLINK :
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	781 case YAFFS_OBJECT_TYPE_SPECIAL :
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	782 default:
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	783 /* TODO? */
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	784 break;
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	785 }
7c7448871973 Make sure mode is sane charles parents: 143 diff changeset	786
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	787 inode->i_flags \|= S_NOATIME;
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	788
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	789 inode->i_ino = obj->objectId;
24 4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	790 inode->i_mode = obj->yst_mode;
4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	791 inode->i_uid = obj->yst_uid;
4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	792 inode->i_gid = obj->yst_gid;
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	793 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	794 inode->i_blksize = inode->i_sb->s_blocksize;
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	795 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	796 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
ddfefbbf40d3 * empty log message * charles parents: diff changeset	797
24 4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	798 inode->i_rdev = old_decode_dev(obj->yst_rdev);
78 222238621f18 lindent marty parents: 72 diff changeset	799 inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	800 inode->i_atime.tv_nsec = 0;
78 222238621f18 lindent marty parents: 72 diff changeset	801 inode->i_mtime.tv_sec = (time_t) obj->yst_mtime;
222238621f18 lindent marty parents: 72 diff changeset	802 inode->i_mtime.tv_nsec = 0;
222238621f18 lindent marty parents: 72 diff changeset	803 inode->i_ctime.tv_sec = (time_t) obj->yst_ctime;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	804 inode->i_ctime.tv_nsec = 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	805 #else
24 4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	806 inode->i_rdev = obj->yst_rdev;
4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	807 inode->i_atime = obj->yst_atime;
4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	808 inode->i_mtime = obj->yst_mtime;
4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	809 inode->i_ctime = obj->yst_ctime;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	810 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	811 inode->i_size = yaffs_GetObjectFileLength(obj);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	812 inode->i_blocks = (inode->i_size + 511) >> 9;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	813
ddfefbbf40d3 * empty log message * charles parents: diff changeset	814 inode->i_nlink = yaffs_GetObjectLinkCount(obj);
78 222238621f18 lindent marty parents: 72 diff changeset	815
222238621f18 lindent marty parents: 72 diff changeset	816 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	817 (KERN_DEBUG
222238621f18 lindent marty parents: 72 diff changeset	818 "yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
222238621f18 lindent marty parents: 72 diff changeset	819 inode->i_mode, inode->i_uid, inode->i_gid,
222238621f18 lindent marty parents: 72 diff changeset	820 (int)inode->i_size, atomic_read(&inode->i_count)));
222238621f18 lindent marty parents: 72 diff changeset	821
222238621f18 lindent marty parents: 72 diff changeset	822 switch (obj->yst_mode & S_IFMT) {
222238621f18 lindent marty parents: 72 diff changeset	823 default: /* fifo, device or socket */
13 0d6eaf1cfded Fix 2.6 special inodes charles parents: 11 diff changeset	824 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	825 init_special_inode(inode, obj->yst_mode,
222238621f18 lindent marty parents: 72 diff changeset	826 old_decode_dev(obj->yst_rdev));
13 0d6eaf1cfded Fix 2.6 special inodes charles parents: 11 diff changeset	827 #else
78 222238621f18 lindent marty parents: 72 diff changeset	828 init_special_inode(inode, obj->yst_mode,
222238621f18 lindent marty parents: 72 diff changeset	829 (dev_t) (obj->yst_rdev));
222238621f18 lindent marty parents: 72 diff changeset	830 #endif
222238621f18 lindent marty parents: 72 diff changeset	831 break;
222238621f18 lindent marty parents: 72 diff changeset	832 case S_IFREG: /* file */
222238621f18 lindent marty parents: 72 diff changeset	833 inode->i_op = &yaffs_file_inode_operations;
222238621f18 lindent marty parents: 72 diff changeset	834 inode->i_fop = &yaffs_file_operations;
222238621f18 lindent marty parents: 72 diff changeset	835 inode->i_mapping->a_ops =
222238621f18 lindent marty parents: 72 diff changeset	836 &yaffs_file_address_operations;
222238621f18 lindent marty parents: 72 diff changeset	837 break;
222238621f18 lindent marty parents: 72 diff changeset	838 case S_IFDIR: /* directory */
222238621f18 lindent marty parents: 72 diff changeset	839 inode->i_op = &yaffs_dir_inode_operations;
222238621f18 lindent marty parents: 72 diff changeset	840 inode->i_fop = &yaffs_dir_operations;
222238621f18 lindent marty parents: 72 diff changeset	841 break;
222238621f18 lindent marty parents: 72 diff changeset	842 case S_IFLNK: /* symlink */
222238621f18 lindent marty parents: 72 diff changeset	843 inode->i_op = &yaffs_symlink_inode_operations;
222238621f18 lindent marty parents: 72 diff changeset	844 break;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	845 }
78 222238621f18 lindent marty parents: 72 diff changeset	846
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	847 yaffs_InodeToObjectLV(inode) = obj;
27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	848
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	849 obj->myInode = inode;
78 222238621f18 lindent marty parents: 72 diff changeset	850
222238621f18 lindent marty parents: 72 diff changeset	851 } else {
222238621f18 lindent marty parents: 72 diff changeset	852 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	853 (KERN_DEBUG "yaffs_FileInode invalid parameters\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	854 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	855
ddfefbbf40d3 * empty log message * charles parents: diff changeset	856 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	857
78 222238621f18 lindent marty parents: 72 diff changeset	858 struct inode yaffs_get_inode(struct super_block sb, int mode, int dev,
222238621f18 lindent marty parents: 72 diff changeset	859 yaffs_Object * obj)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	860 {
78 222238621f18 lindent marty parents: 72 diff changeset	861 struct inode *inode;
222238621f18 lindent marty parents: 72 diff changeset	862
222238621f18 lindent marty parents: 72 diff changeset	863 if (!sb) {
222238621f18 lindent marty parents: 72 diff changeset	864 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	865 (KERN_DEBUG "yaffs_get_inode for NULL super_block!!\n"));
222238621f18 lindent marty parents: 72 diff changeset	866 return NULL;
222238621f18 lindent marty parents: 72 diff changeset	867
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	868 }
78 222238621f18 lindent marty parents: 72 diff changeset	869
222238621f18 lindent marty parents: 72 diff changeset	870 if (!obj) {
222238621f18 lindent marty parents: 72 diff changeset	871 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	872 (KERN_DEBUG "yaffs_get_inode for NULL object!!\n"));
222238621f18 lindent marty parents: 72 diff changeset	873 return NULL;
222238621f18 lindent marty parents: 72 diff changeset	874
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	875 }
78 222238621f18 lindent marty parents: 72 diff changeset	876
222238621f18 lindent marty parents: 72 diff changeset	877 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	878 (KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	879
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	880 inode = Y_IGET(sb, obj->objectId);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	881 if(IS_ERR(inode))
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	882 return NULL;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	883
78 222238621f18 lindent marty parents: 72 diff changeset	884 /* NB Side effect: iget calls back to yaffs_read_inode(). */
222238621f18 lindent marty parents: 72 diff changeset	885 /* iget also increments the inode's i_count */
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	886 /* NB You can't be holding grossLock or deadlock will happen! */
78 222238621f18 lindent marty parents: 72 diff changeset	887
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	888 return inode;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	889 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	890
78 222238621f18 lindent marty parents: 72 diff changeset	891 static ssize_t yaffs_file_write(struct file f, const char buf, size_t n,
222238621f18 lindent marty parents: 72 diff changeset	892 loff_t * pos)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	893 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	894 yaffs_Object *obj;
78 222238621f18 lindent marty parents: 72 diff changeset	895 int nWritten, ipos;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	896 struct inode *inode;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	897 yaffs_Device *dev;
78 222238621f18 lindent marty parents: 72 diff changeset	898
222238621f18 lindent marty parents: 72 diff changeset	899 obj = yaffs_DentryToObject(f->f_dentry);
222238621f18 lindent marty parents: 72 diff changeset	900
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	901 dev = obj->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	902
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	903 yaffs_GrossLock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	904
ddfefbbf40d3 * empty log message * charles parents: diff changeset	905 inode = f->f_dentry->d_inode;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	906
78 222238621f18 lindent marty parents: 72 diff changeset	907 if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	908 ipos = inode->i_size;
78 222238621f18 lindent marty parents: 72 diff changeset	909 } else {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	910 ipos = *pos;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	911 }
78 222238621f18 lindent marty parents: 72 diff changeset	912
222238621f18 lindent marty parents: 72 diff changeset	913 if (!obj) {
222238621f18 lindent marty parents: 72 diff changeset	914 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	915 (KERN_DEBUG "yaffs_file_write: hey obj is null!\n"));
222238621f18 lindent marty parents: 72 diff changeset	916 } else {
222238621f18 lindent marty parents: 72 diff changeset	917 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	918 (KERN_DEBUG
222238621f18 lindent marty parents: 72 diff changeset	919 "yaffs_file_write about to write writing %d bytes"
222238621f18 lindent marty parents: 72 diff changeset	920 "to object %d at %d\n",
222238621f18 lindent marty parents: 72 diff changeset	921 n, obj->objectId, ipos));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	922 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	923
78 222238621f18 lindent marty parents: 72 diff changeset	924 nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	925
78 222238621f18 lindent marty parents: 72 diff changeset	926 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	927 (KERN_DEBUG "yaffs_file_write writing %d bytes, %d written at %d\n",
222238621f18 lindent marty parents: 72 diff changeset	928 n, nWritten, ipos));
222238621f18 lindent marty parents: 72 diff changeset	929 if (nWritten > 0) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	930 ipos += nWritten;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	931 *pos = ipos;
78 222238621f18 lindent marty parents: 72 diff changeset	932 if (ipos > inode->i_size) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	933 inode->i_size = ipos;
78 222238621f18 lindent marty parents: 72 diff changeset	934 inode->i_blocks = (ipos + 511) >> 9;
222238621f18 lindent marty parents: 72 diff changeset	935
222238621f18 lindent marty parents: 72 diff changeset	936 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	937 (KERN_DEBUG
222238621f18 lindent marty parents: 72 diff changeset	938 "yaffs_file_write size updated to %d bytes, "
222238621f18 lindent marty parents: 72 diff changeset	939 "%d blocks\n",
222238621f18 lindent marty parents: 72 diff changeset	940 ipos, (int)(inode->i_blocks)));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	941 }
78 222238621f18 lindent marty parents: 72 diff changeset	942
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	943 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	944 yaffs_GrossUnlock(dev);
116 c110f6f02466 Handle partial writes more gracefully: return partial byte counts, return tpoynor parents: 115 diff changeset	945 return nWritten == 0 ? -ENOSPC : nWritten;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	946 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	947
ddfefbbf40d3 * empty log message * charles parents: diff changeset	948 static int yaffs_readdir(struct file f, void dirent, filldir_t filldir)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	949 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	950 yaffs_Object *obj;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	951 yaffs_Device *dev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	952 struct inode *inode = f->f_dentry->d_inode;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	953 unsigned long offset, curoffs;
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	954 struct ylist_head *i;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	955 yaffs_Object *l;
78 222238621f18 lindent marty parents: 72 diff changeset	956
222238621f18 lindent marty parents: 72 diff changeset	957 char name[YAFFS_MAX_NAME_LENGTH + 1];
222238621f18 lindent marty parents: 72 diff changeset	958
222238621f18 lindent marty parents: 72 diff changeset	959 obj = yaffs_DentryToObject(f->f_dentry);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	960 dev = obj->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	961
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	962 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	963
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	964 offset = f->f_pos;
78 222238621f18 lindent marty parents: 72 diff changeset	965
222238621f18 lindent marty parents: 72 diff changeset	966 T(YAFFS_TRACE_OS, ("yaffs_readdir: starting at %d\n", (int)offset));
222238621f18 lindent marty parents: 72 diff changeset	967
222238621f18 lindent marty parents: 72 diff changeset	968 if (offset == 0) {
222238621f18 lindent marty parents: 72 diff changeset	969 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	970 (KERN_DEBUG "yaffs_readdir: entry . ino %d \n",
222238621f18 lindent marty parents: 72 diff changeset	971 (int)inode->i_ino));
222238621f18 lindent marty parents: 72 diff changeset	972 if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR)
222238621f18 lindent marty parents: 72 diff changeset	973 < 0) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	974 goto out;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	975 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	976 offset++;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	977 f->f_pos++;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	978 }
78 222238621f18 lindent marty parents: 72 diff changeset	979 if (offset == 1) {
222238621f18 lindent marty parents: 72 diff changeset	980 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	981 (KERN_DEBUG "yaffs_readdir: entry .. ino %d \n",
222238621f18 lindent marty parents: 72 diff changeset	982 (int)f->f_dentry->d_parent->d_inode->i_ino));
222238621f18 lindent marty parents: 72 diff changeset	983 if (filldir
222238621f18 lindent marty parents: 72 diff changeset	984 (dirent, "..", 2, offset,
222238621f18 lindent marty parents: 72 diff changeset	985 f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	986 goto out;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	987 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	988 offset++;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	989 f->f_pos++;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	990 }
78 222238621f18 lindent marty parents: 72 diff changeset	991
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	992 curoffs = 1;
78 222238621f18 lindent marty parents: 72 diff changeset	993
120 8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	994 /* If the directory has changed since the open or last call to
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	995 readdir, rewind to after the 2 canned entries. */
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	996
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	997 if (f->f_version != inode->i_version) {
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	998 offset = 2;
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	999 f->f_pos = offset;
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	1000 f->f_version = inode->i_version;
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	1001 }
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	1002
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1003 ylist_for_each(i, &obj->variant.directoryVariant.children) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1004 curoffs++;
78 222238621f18 lindent marty parents: 72 diff changeset	1005 if (curoffs >= offset) {
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1006 l = ylist_entry(i, yaffs_Object, siblings);
78 222238621f18 lindent marty parents: 72 diff changeset	1007
222238621f18 lindent marty parents: 72 diff changeset	1008 yaffs_GetObjectName(l, name,
222238621f18 lindent marty parents: 72 diff changeset	1009 YAFFS_MAX_NAME_LENGTH + 1);
222238621f18 lindent marty parents: 72 diff changeset	1010 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1011 (KERN_DEBUG "yaffs_readdir: %s inode %d\n", name,
222238621f18 lindent marty parents: 72 diff changeset	1012 yaffs_GetObjectInode(l)));
222238621f18 lindent marty parents: 72 diff changeset	1013
222238621f18 lindent marty parents: 72 diff changeset	1014 if (filldir(dirent,
222238621f18 lindent marty parents: 72 diff changeset	1015 name,
222238621f18 lindent marty parents: 72 diff changeset	1016 strlen(name),
222238621f18 lindent marty parents: 72 diff changeset	1017 offset,
222238621f18 lindent marty parents: 72 diff changeset	1018 yaffs_GetObjectInode(l),
222238621f18 lindent marty parents: 72 diff changeset	1019 yaffs_GetObjectType(l))
222238621f18 lindent marty parents: 72 diff changeset	1020 < 0) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1021 goto up_and_out;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1022 }
78 222238621f18 lindent marty parents: 72 diff changeset	1023
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1024 offset++;
78 222238621f18 lindent marty parents: 72 diff changeset	1025 f->f_pos++;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1026 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1027 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1028
78 222238621f18 lindent marty parents: 72 diff changeset	1029 up_and_out:
222238621f18 lindent marty parents: 72 diff changeset	1030 out:
222238621f18 lindent marty parents: 72 diff changeset	1031
222238621f18 lindent marty parents: 72 diff changeset	1032 yaffs_GrossUnlock(dev);
222238621f18 lindent marty parents: 72 diff changeset	1033
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1034 return 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1035 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1036
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1037 /*
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1038 * File creation. Allocate an inode, and we're done..
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1039 */
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1040 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	1041 static int yaffs_mknod(struct inode dir, struct dentry dentry, int mode,
222238621f18 lindent marty parents: 72 diff changeset	1042 dev_t rdev)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1043 #else
78 222238621f18 lindent marty parents: 72 diff changeset	1044 static int yaffs_mknod(struct inode dir, struct dentry dentry, int mode,
222238621f18 lindent marty parents: 72 diff changeset	1045 int rdev)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1046 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1047 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1048 struct inode *inode;
78 222238621f18 lindent marty parents: 72 diff changeset	1049
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1050 yaffs_Object *obj = NULL;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1051 yaffs_Device *dev;
78 222238621f18 lindent marty parents: 72 diff changeset	1052
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1053 yaffs_Object *parent = yaffs_InodeToObject(dir);
78 222238621f18 lindent marty parents: 72 diff changeset	1054
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1055 int error = -ENOSPC;
38 14315c63b7a5 Set the correct uid/gid of newly created files when: use fsuid & fsgid and take care when the SGID bit is set on the parent directory. luc parents: 34 diff changeset	1056 uid_t uid = current->fsuid;
14315c63b7a5 Set the correct uid/gid of newly created files when: use fsuid & fsgid and take care when the SGID bit is set on the parent directory. luc parents: 34 diff changeset	1057 gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1058
139 f9d57534a6bd Fix SGID problem charles parents: 137 diff changeset	1059 if((dir->i_mode & S_ISGID) && S_ISDIR(mode))
f9d57534a6bd Fix SGID problem charles parents: 137 diff changeset	1060 mode \|= S_ISGID;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1061
78 222238621f18 lindent marty parents: 72 diff changeset	1062 if (parent) {
222238621f18 lindent marty parents: 72 diff changeset	1063 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1064 (KERN_DEBUG "yaffs_mknod: parent object %d type %d\n",
222238621f18 lindent marty parents: 72 diff changeset	1065 parent->objectId, parent->variantType));
222238621f18 lindent marty parents: 72 diff changeset	1066 } else {
222238621f18 lindent marty parents: 72 diff changeset	1067 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1068 (KERN_DEBUG "yaffs_mknod: could not get parent object\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1069 return -EPERM;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1070 }
78 222238621f18 lindent marty parents: 72 diff changeset	1071
222238621f18 lindent marty parents: 72 diff changeset	1072 T(YAFFS_TRACE_OS, ("yaffs_mknod: making oject for %s, "
222238621f18 lindent marty parents: 72 diff changeset	1073 "mode %x dev %x\n",
222238621f18 lindent marty parents: 72 diff changeset	1074 dentry->d_name.name, mode, rdev));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1075
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1076 dev = parent->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	1077
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1078 yaffs_GrossLock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1079
78 222238621f18 lindent marty parents: 72 diff changeset	1080 switch (mode & S_IFMT) {
222238621f18 lindent marty parents: 72 diff changeset	1081 default:
222238621f18 lindent marty parents: 72 diff changeset	1082 /* Special (socket, fifo, device...) */
222238621f18 lindent marty parents: 72 diff changeset	1083 T(YAFFS_TRACE_OS, (KERN_DEBUG
222238621f18 lindent marty parents: 72 diff changeset	1084 "yaffs_mknod: making special\n"));
13 0d6eaf1cfded Fix 2.6 special inodes charles parents: 11 diff changeset	1085 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	1086 obj =
222238621f18 lindent marty parents: 72 diff changeset	1087 yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
222238621f18 lindent marty parents: 72 diff changeset	1088 gid, old_encode_dev(rdev));
13 0d6eaf1cfded Fix 2.6 special inodes charles parents: 11 diff changeset	1089 #else
78 222238621f18 lindent marty parents: 72 diff changeset	1090 obj =
222238621f18 lindent marty parents: 72 diff changeset	1091 yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
222238621f18 lindent marty parents: 72 diff changeset	1092 gid, rdev);
222238621f18 lindent marty parents: 72 diff changeset	1093 #endif
222238621f18 lindent marty parents: 72 diff changeset	1094 break;
222238621f18 lindent marty parents: 72 diff changeset	1095 case S_IFREG: /* file */
222238621f18 lindent marty parents: 72 diff changeset	1096 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
222238621f18 lindent marty parents: 72 diff changeset	1097 obj =
222238621f18 lindent marty parents: 72 diff changeset	1098 yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
222238621f18 lindent marty parents: 72 diff changeset	1099 gid);
222238621f18 lindent marty parents: 72 diff changeset	1100 break;
222238621f18 lindent marty parents: 72 diff changeset	1101 case S_IFDIR: /* directory */
222238621f18 lindent marty parents: 72 diff changeset	1102 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1103 (KERN_DEBUG "yaffs_mknod: making directory\n"));
222238621f18 lindent marty parents: 72 diff changeset	1104 obj =
222238621f18 lindent marty parents: 72 diff changeset	1105 yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
222238621f18 lindent marty parents: 72 diff changeset	1106 uid, gid);
222238621f18 lindent marty parents: 72 diff changeset	1107 break;
222238621f18 lindent marty parents: 72 diff changeset	1108 case S_IFLNK: /* symlink */
222238621f18 lindent marty parents: 72 diff changeset	1109 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
222238621f18 lindent marty parents: 72 diff changeset	1110 obj = NULL; /* Do we ever get here? */
222238621f18 lindent marty parents: 72 diff changeset	1111 break;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1112 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1113
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1114 /* Can not call yaffs_get_inode() with gross lock held */
1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1115 yaffs_GrossUnlock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1116
222238621f18 lindent marty parents: 72 diff changeset	1117 if (obj) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1118 inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1119 d_instantiate(dentry, inode);
78 222238621f18 lindent marty parents: 72 diff changeset	1120 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1121 (KERN_DEBUG "yaffs_mknod created object %d count = %d\n",
222238621f18 lindent marty parents: 72 diff changeset	1122 obj->objectId, atomic_read(&inode->i_count)));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1123 error = 0;
78 222238621f18 lindent marty parents: 72 diff changeset	1124 } else {
222238621f18 lindent marty parents: 72 diff changeset	1125 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1126 (KERN_DEBUG "yaffs_mknod failed making object\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1127 error = -ENOMEM;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1128 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1129
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1130 return error;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1131 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1132
78 222238621f18 lindent marty parents: 72 diff changeset	1133 static int yaffs_mkdir(struct inode dir, struct dentry dentry, int mode)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1134 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1135 int retVal;
78 222238621f18 lindent marty parents: 72 diff changeset	1136 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mkdir\n"));
222238621f18 lindent marty parents: 72 diff changeset	1137 retVal = yaffs_mknod(dir, dentry, mode \| S_IFDIR, 0);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1138 #if 0
78 222238621f18 lindent marty parents: 72 diff changeset	1139 /* attempt to fix dir bug - didn't work */
222238621f18 lindent marty parents: 72 diff changeset	1140 if (!retVal) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1141 dget(dentry);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1142 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1143 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1144 return retVal;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1145 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1146
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1147 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	1148 static int yaffs_create(struct inode dir, struct dentry dentry, int mode,
222238621f18 lindent marty parents: 72 diff changeset	1149 struct nameidata *n)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1150 #else
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1151 static int yaffs_create(struct inode dir, struct dentry dentry, int mode)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1152 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1153 {
78 222238621f18 lindent marty parents: 72 diff changeset	1154 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_create\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1155 return yaffs_mknod(dir, dentry, mode \| S_IFREG, 0);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1156 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1157
78 222238621f18 lindent marty parents: 72 diff changeset	1158 static int yaffs_unlink(struct inode dir, struct dentry dentry)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1159 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1160 int retVal;
78 222238621f18 lindent marty parents: 72 diff changeset	1161
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1162 yaffs_Device *dev;
78 222238621f18 lindent marty parents: 72 diff changeset	1163
222238621f18 lindent marty parents: 72 diff changeset	1164 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1165 (KERN_DEBUG "yaffs_unlink %d:%s\n", (int)(dir->i_ino),
222238621f18 lindent marty parents: 72 diff changeset	1166 dentry->d_name.name));
222238621f18 lindent marty parents: 72 diff changeset	1167
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1168 dev = yaffs_InodeToObject(dir)->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	1169
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1170 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1171
222238621f18 lindent marty parents: 72 diff changeset	1172 retVal = yaffs_Unlink(yaffs_InodeToObject(dir), dentry->d_name.name);
222238621f18 lindent marty parents: 72 diff changeset	1173
222238621f18 lindent marty parents: 72 diff changeset	1174 if (retVal == YAFFS_OK) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1175 dentry->d_inode->i_nlink--;
120 8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	1176 dir->i_version++;
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	1177 yaffs_GrossUnlock(dev);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1178 mark_inode_dirty(dentry->d_inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1179 return 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1180 }
120 8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	1181 yaffs_GrossUnlock(dev);
8d8735105bd4 Add Todds readdir rewind mechanism charles parents: 118 diff changeset	1182 return -ENOTEMPTY;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1183 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1184
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1185 /*
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1186 * Create a link...
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1187 */
78 222238621f18 lindent marty parents: 72 diff changeset	1188 static int yaffs_link(struct dentry old_dentry, struct inode dir,
222238621f18 lindent marty parents: 72 diff changeset	1189 struct dentry *dentry)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1190 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1191 struct inode *inode = old_dentry->d_inode;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1192 yaffs_Object *obj = NULL;
78 222238621f18 lindent marty parents: 72 diff changeset	1193 yaffs_Object *link = NULL;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1194 yaffs_Device *dev;
78 222238621f18 lindent marty parents: 72 diff changeset	1195
222238621f18 lindent marty parents: 72 diff changeset	1196 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_link\n"));
222238621f18 lindent marty parents: 72 diff changeset	1197
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1198 obj = yaffs_InodeToObject(inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1199 dev = obj->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	1200
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1201 yaffs_GrossLock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1202
78 222238621f18 lindent marty parents: 72 diff changeset	1203 if (!S_ISDIR(inode->i_mode)) /* Don't link directories */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1204 {
78 222238621f18 lindent marty parents: 72 diff changeset	1205 link =
222238621f18 lindent marty parents: 72 diff changeset	1206 yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
222238621f18 lindent marty parents: 72 diff changeset	1207 obj);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1208 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1209
78 222238621f18 lindent marty parents: 72 diff changeset	1210 if (link) {
222238621f18 lindent marty parents: 72 diff changeset	1211 old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1212 d_instantiate(dentry, old_dentry->d_inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1213 atomic_inc(&old_dentry->d_inode->i_count);
78 222238621f18 lindent marty parents: 72 diff changeset	1214 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1215 (KERN_DEBUG "yaffs_link link count %d i_count %d\n",
222238621f18 lindent marty parents: 72 diff changeset	1216 old_dentry->d_inode->i_nlink,
222238621f18 lindent marty parents: 72 diff changeset	1217 atomic_read(&old_dentry->d_inode->i_count)));
222238621f18 lindent marty parents: 72 diff changeset	1218
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1219 }
78 222238621f18 lindent marty parents: 72 diff changeset	1220
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1221 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1222
78 222238621f18 lindent marty parents: 72 diff changeset	1223 if (link) {
222238621f18 lindent marty parents: 72 diff changeset	1224
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1225 return 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1226 }
78 222238621f18 lindent marty parents: 72 diff changeset	1227
222238621f18 lindent marty parents: 72 diff changeset	1228 return -EPERM;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1229 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1230
78 222238621f18 lindent marty parents: 72 diff changeset	1231 static int yaffs_symlink(struct inode dir, struct dentry dentry,
222238621f18 lindent marty parents: 72 diff changeset	1232 const char *symname)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1233 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1234 yaffs_Object *obj;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1235 yaffs_Device *dev;
38 14315c63b7a5 Set the correct uid/gid of newly created files when: use fsuid & fsgid and take care when the SGID bit is set on the parent directory. luc parents: 34 diff changeset	1236 uid_t uid = current->fsuid;
14315c63b7a5 Set the correct uid/gid of newly created files when: use fsuid & fsgid and take care when the SGID bit is set on the parent directory. luc parents: 34 diff changeset	1237 gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
78 222238621f18 lindent marty parents: 72 diff changeset	1238
222238621f18 lindent marty parents: 72 diff changeset	1239 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_symlink\n"));
222238621f18 lindent marty parents: 72 diff changeset	1240
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1241 dev = yaffs_InodeToObject(dir)->myDev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1242 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1243 obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name,
222238621f18 lindent marty parents: 72 diff changeset	1244 S_IFLNK \| S_IRWXUGO, uid, gid, symname);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1245 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1246
78 222238621f18 lindent marty parents: 72 diff changeset	1247 if (obj) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1248
78 222238621f18 lindent marty parents: 72 diff changeset	1249 struct inode *inode;
222238621f18 lindent marty parents: 72 diff changeset	1250
24 4ebabd859f38 Some improvements to garbage collection and st_xxx to yst_xxx changes charles parents: 21 diff changeset	1251 inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1252 d_instantiate(dentry, inode);
78 222238621f18 lindent marty parents: 72 diff changeset	1253 T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink created OK\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1254 return 0;
78 222238621f18 lindent marty parents: 72 diff changeset	1255 } else {
222238621f18 lindent marty parents: 72 diff changeset	1256 T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink not created\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1257
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1258 }
78 222238621f18 lindent marty parents: 72 diff changeset	1259
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1260 return -ENOMEM;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1261 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1262
78 222238621f18 lindent marty parents: 72 diff changeset	1263 static int yaffs_sync_object(struct file file, struct dentry dentry,
222238621f18 lindent marty parents: 72 diff changeset	1264 int datasync)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1265 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1266
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1267 yaffs_Object *obj;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1268 yaffs_Device *dev;
78 222238621f18 lindent marty parents: 72 diff changeset	1269
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1270 obj = yaffs_DentryToObject(dentry);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1271
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1272 dev = obj->myDev;
78 222238621f18 lindent marty parents: 72 diff changeset	1273
222238621f18 lindent marty parents: 72 diff changeset	1274 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_object\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1275 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1276 yaffs_FlushFile(obj, 1);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1277 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1278 return 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1279 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1280
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1281 /*
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1282 * The VFS layer already does all the dentry stuff for rename.
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1283 *
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1284 * NB: POSIX says you can rename an object over an old object of the same name
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1285 */
78 222238621f18 lindent marty parents: 72 diff changeset	1286 static int yaffs_rename(struct inode old_dir, struct dentry old_dentry,
222238621f18 lindent marty parents: 72 diff changeset	1287 struct inode new_dir, struct dentry new_dentry)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1288 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1289 yaffs_Device *dev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1290 int retVal = YAFFS_FAIL;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1291 yaffs_Object *target;
78 222238621f18 lindent marty parents: 72 diff changeset	1292
86 9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	1293 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_rename\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1294 dev = yaffs_InodeToObject(old_dir)->myDev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1295
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1296 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1297
222238621f18 lindent marty parents: 72 diff changeset	1298 /* Check if the target is an existing directory that is not empty. */
222238621f18 lindent marty parents: 72 diff changeset	1299 target =
222238621f18 lindent marty parents: 72 diff changeset	1300 yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
222238621f18 lindent marty parents: 72 diff changeset	1301 new_dentry->d_name.name);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1302
f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1303
78 222238621f18 lindent marty parents: 72 diff changeset	1304
222238621f18 lindent marty parents: 72 diff changeset	1305 if (target &&
222238621f18 lindent marty parents: 72 diff changeset	1306 target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1307 !ylist_empty(&target->variant.directoryVariant.children)) {
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1308
86 9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	1309 T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	1310
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1311 retVal = YAFFS_FAIL;
78 222238621f18 lindent marty parents: 72 diff changeset	1312 } else {
222238621f18 lindent marty parents: 72 diff changeset	1313
222238621f18 lindent marty parents: 72 diff changeset	1314 /* Now does unlinking internally using shadowing mechanism */
86 9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	1315 T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1316
78 222238621f18 lindent marty parents: 72 diff changeset	1317 retVal =
222238621f18 lindent marty parents: 72 diff changeset	1318 yaffs_RenameObject(yaffs_InodeToObject(old_dir),
222238621f18 lindent marty parents: 72 diff changeset	1319 old_dentry->d_name.name,
222238621f18 lindent marty parents: 72 diff changeset	1320 yaffs_InodeToObject(new_dir),
222238621f18 lindent marty parents: 72 diff changeset	1321 new_dentry->d_name.name);
222238621f18 lindent marty parents: 72 diff changeset	1322
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1323 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1324 yaffs_GrossUnlock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1325
222238621f18 lindent marty parents: 72 diff changeset	1326 if (retVal == YAFFS_OK) {
91 80d3628fbd18 Fix problem introduced my mv over fix charles parents: 86 diff changeset	1327 if(target) {
80d3628fbd18 Fix problem introduced my mv over fix charles parents: 86 diff changeset	1328 new_dentry->d_inode->i_nlink--;
80d3628fbd18 Fix problem introduced my mv over fix charles parents: 86 diff changeset	1329 mark_inode_dirty(new_dentry->d_inode);
80d3628fbd18 Fix problem introduced my mv over fix charles parents: 86 diff changeset	1330 }
78 222238621f18 lindent marty parents: 72 diff changeset	1331
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1332 return 0;
78 222238621f18 lindent marty parents: 72 diff changeset	1333 } else {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1334 return -ENOTEMPTY;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1335 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1336
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1337 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1338
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1339 static int yaffs_setattr(struct dentry dentry, struct iattr attr)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1340 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1341 struct inode *inode = dentry->d_inode;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1342 int error;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1343 yaffs_Device *dev;
78 222238621f18 lindent marty parents: 72 diff changeset	1344
222238621f18 lindent marty parents: 72 diff changeset	1345 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1346 (KERN_DEBUG "yaffs_setattr of object %d\n",
222238621f18 lindent marty parents: 72 diff changeset	1347 yaffs_InodeToObject(inode)->objectId));
222238621f18 lindent marty parents: 72 diff changeset	1348
222238621f18 lindent marty parents: 72 diff changeset	1349 if ((error = inode_change_ok(inode, attr)) == 0) {
222238621f18 lindent marty parents: 72 diff changeset	1350
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1351 dev = yaffs_InodeToObject(inode)->myDev;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1352 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1353 if (yaffs_SetAttributes(yaffs_InodeToObject(inode), attr) ==
222238621f18 lindent marty parents: 72 diff changeset	1354 YAFFS_OK) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1355 error = 0;
78 222238621f18 lindent marty parents: 72 diff changeset	1356 } else {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1357 error = -EPERM;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1358 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1359 yaffs_GrossUnlock(dev);
25 510637d0d0d1 Apply Luc's patches charles parents: 24 diff changeset	1360 if (!error)
78 222238621f18 lindent marty parents: 72 diff changeset	1361 error = inode_setattr(inode, attr);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1362 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1363 return error;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1364 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1365
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1366 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1367 static int yaffs_statfs(struct dentry dentry, struct kstatfs buf)
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1368 {
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1369 yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1370 struct super_block *sb = dentry->d_sb;
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1371 #elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1372 static int yaffs_statfs(struct super_block sb, struct kstatfs buf)
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1373 {
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1374 yaffs_Device *dev = yaffs_SuperToDevice(sb);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1375 #else
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1376 static int yaffs_statfs(struct super_block sb, struct statfs buf)
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1377 {
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1378 yaffs_Device *dev = yaffs_SuperToDevice(sb);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1379 #endif
16 721e278c9eb3 Fix df size problem charles parents: 13 diff changeset	1380
78 222238621f18 lindent marty parents: 72 diff changeset	1381 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_statfs\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1382
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1383 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1384
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1385 buf->f_type = YAFFS_MAGIC;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1386 buf->f_bsize = sb->s_blocksize;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1387 buf->f_namelen = 255;
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1388
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1389 if(dev->nDataBytesPerChunk & (dev->nDataBytesPerChunk - 1)){
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1390 /* Do this if chunk size is not a power of 2 */
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1391
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1392 uint64_t bytesInDev;
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1393 uint64_t bytesFree;
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1394
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1395 bytesInDev = ((uint64_t)((dev->endBlock - dev->startBlock +1))) *
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1396 ((uint64_t)(dev->nChunksPerBlock * dev->nDataBytesPerChunk));
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1397
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1398 do_div(bytesInDev,sb->s_blocksize); /* bytesInDev becomes the number of blocks */
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1399 buf->f_blocks = bytesInDev;
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1400
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1401 bytesFree = ((uint64_t)(yaffs_GetNumberOfFreeChunks(dev))) *
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1402 ((uint64_t)(dev->nDataBytesPerChunk));
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1403
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1404 do_div(bytesFree,sb->s_blocksize);
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1405
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1406 buf->f_bfree = bytesFree;
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1407
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1408 } else if (sb->s_blocksize > dev->nDataBytesPerChunk) {
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1409
78 222238621f18 lindent marty parents: 72 diff changeset	1410 buf->f_blocks =
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1411 (dev->endBlock - dev->startBlock + 1) *
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1412 dev->nChunksPerBlock /
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1413 (sb->s_blocksize / dev->nDataBytesPerChunk);
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1414 buf->f_bfree =
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1415 yaffs_GetNumberOfFreeChunks(dev) /
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1416 (sb->s_blocksize / dev->nDataBytesPerChunk);
78 222238621f18 lindent marty parents: 72 diff changeset	1417 } else {
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1418 buf->f_blocks =
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1419 (dev->endBlock - dev->startBlock + 1) *
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1420 dev->nChunksPerBlock *
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1421 (dev->nDataBytesPerChunk / sb->s_blocksize);
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1422
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1423 buf->f_bfree =
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1424 yaffs_GetNumberOfFreeChunks(dev) *
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1425 (dev->nDataBytesPerChunk / sb->s_blocksize);
16 721e278c9eb3 Fix df size problem charles parents: 13 diff changeset	1426 }
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1427
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1428
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1429 buf->f_files = 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1430 buf->f_ffree = 0;
78 222238621f18 lindent marty parents: 72 diff changeset	1431 buf->f_bavail = buf->f_bfree;
222238621f18 lindent marty parents: 72 diff changeset	1432
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1433 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1434 return 0;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1435 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1436
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1437
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1438 static int yaffs_do_sync_fs(struct super_block *sb)
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1439 {
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1440
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1441 yaffs_Device *dev = yaffs_SuperToDevice(sb);
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1442 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_do_sync_fs\n"));
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1443
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1444 if(sb->s_dirt) {
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1445 yaffs_GrossLock(dev);
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1446
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1447 if(dev){
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1448 yaffs_FlushEntireDeviceCache(dev);
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1449 yaffs_CheckpointSave(dev);
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1450 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1451
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1452 yaffs_GrossUnlock(dev);
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1453
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1454 sb->s_dirt = 0;
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1455 }
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1456 return 0;
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1457 }
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1458
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1459
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1460 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1461 static void yaffs_write_super(struct super_block *sb)
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1462 #else
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1463 static int yaffs_write_super(struct super_block *sb)
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1464 #endif
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1465 {
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1466
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1467 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_write_super\n"));
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1468 yaffs_do_sync_fs(sb);
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1469 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1470 return 0;
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1471 #endif
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1472 }
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1473
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1474
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1475 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1476 static int yaffs_sync_fs(struct super_block *sb, int wait)
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1477 #else
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1478 static int yaffs_sync_fs(struct super_block *sb)
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1479 #endif
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1480 {
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1481
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1482 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1483
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1484 yaffs_do_sync_fs(sb);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1485
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1486 return 0;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1487
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1488 }
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1489
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1490 #ifdef YAFFS_USE_OWN_IGET
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1491
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1492 static struct inode * yaffs_iget(struct super_block *sb, unsigned long ino)
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1493 {
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1494 struct inode *inode;
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1495 yaffs_Object *obj;
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1496 yaffs_Device *dev = yaffs_SuperToDevice(sb);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1497
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1498 T(YAFFS_TRACE_OS,
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1499 (KERN_DEBUG "yaffs_iget for %lu\n", ino));
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1500
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1501 inode = iget_locked(sb, ino);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1502 if (!inode)
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1503 return ERR_PTR(-ENOMEM);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1504 if (!(inode->i_state & I_NEW))
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1505 return inode;
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1506
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1507 /* NB This is called as a side effect of other functions, but
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1508 * we had to release the lock to prevent deadlocks, so
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1509 * need to lock again.
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1510 */
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1511
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1512 yaffs_GrossLock(dev);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1513
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1514 obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1515
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1516 yaffs_FillInodeFromObject(inode, obj);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1517
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1518 yaffs_GrossUnlock(dev);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1519
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1520 unlock_new_inode(inode);
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1521 return inode;
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1522 }
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1523
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1524 #else
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1525
78 222238621f18 lindent marty parents: 72 diff changeset	1526 static void yaffs_read_inode(struct inode *inode)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1527 {
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1528 /* NB This is called as a side effect of other functions, but
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1529 * we had to release the lock to prevent deadlocks, so
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1530 * need to lock again.
78 222238621f18 lindent marty parents: 72 diff changeset	1531 */
222238621f18 lindent marty parents: 72 diff changeset	1532
222238621f18 lindent marty parents: 72 diff changeset	1533 yaffs_Object *obj;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1534 yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb);
78 222238621f18 lindent marty parents: 72 diff changeset	1535
222238621f18 lindent marty parents: 72 diff changeset	1536 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1537 (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1538
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1539 yaffs_GrossLock(dev);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1540
78 222238621f18 lindent marty parents: 72 diff changeset	1541 obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
222238621f18 lindent marty parents: 72 diff changeset	1542
222238621f18 lindent marty parents: 72 diff changeset	1543 yaffs_FillInodeFromObject(inode, obj);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1544
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1545 yaffs_GrossUnlock(dev);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1546 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1547
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1548 #endif
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1549
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1550 static YLIST_HEAD(yaffs_dev_list);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1551
195 d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	1552 #if 0 // not used
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1553 static int yaffs_remount_fs(struct super_block sb, int flags, char *data)
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1554 {
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1555 yaffs_Device *dev = yaffs_SuperToDevice(sb);
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1556
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1557 if( *flags & MS_RDONLY ) {
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1558 struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1559
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1560 T(YAFFS_TRACE_OS,
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1561 (KERN_DEBUG "yaffs_remount_fs: %s: RO\n", dev->name ));
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1562
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1563 yaffs_GrossLock(dev);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1564
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1565 yaffs_FlushEntireDeviceCache(dev);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1566
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1567 yaffs_CheckpointSave(dev);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1568
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1569 if (mtd->sync)
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1570 mtd->sync(mtd);
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1571
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1572 yaffs_GrossUnlock(dev);
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1573 }
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1574 else {
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1575 T(YAFFS_TRACE_OS,
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1576 (KERN_DEBUG "yaffs_remount_fs: %s: RW\n", dev->name ));
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1577 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1578
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1579 return 0;
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1580 }
195 d6cd3be40779 Add support 2.6.23 filesystem interface API. imcd parents: 194 diff changeset	1581 #endif
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1582
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1583 static void yaffs_put_super(struct super_block *sb)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1584 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1585 yaffs_Device *dev = yaffs_SuperToDevice(sb);
78 222238621f18 lindent marty parents: 72 diff changeset	1586
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1587 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n"));
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1588
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1589 yaffs_GrossLock(dev);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1590
127 89a8d2461783 Flush entire cache at umount charles parents: 120 diff changeset	1591 yaffs_FlushEntireDeviceCache(dev);
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1592
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1593 yaffs_CheckpointSave(dev);
7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1594
78 222238621f18 lindent marty parents: 72 diff changeset	1595 if (dev->putSuperFunc) {
222238621f18 lindent marty parents: 72 diff changeset	1596 dev->putSuperFunc(sb);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1597 }
181 7bdee2571f8f Add read-only remount patch charles parents: 177 diff changeset	1598
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1599 yaffs_Deinitialise(dev);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1600
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1601 yaffs_GrossUnlock(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1602
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	1603 /* we assume this is protected by lock_kernel() in mount/umount */
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1604 ylist_del(&dev->devList);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1605
128 4b1283b56e5a Fix unmount spare buffer leak charles parents: 127 diff changeset	1606 if(dev->spareBuffer){
4b1283b56e5a Fix unmount spare buffer leak charles parents: 127 diff changeset	1607 YFREE(dev->spareBuffer);
4b1283b56e5a Fix unmount spare buffer leak charles parents: 127 diff changeset	1608 dev->spareBuffer = NULL;
4b1283b56e5a Fix unmount spare buffer leak charles parents: 127 diff changeset	1609 }
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	1610
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1611 kfree(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1612 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1613
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1614
78 222238621f18 lindent marty parents: 72 diff changeset	1615 static void yaffs_MTDPutSuper(struct super_block *sb)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1616 {
78 222238621f18 lindent marty parents: 72 diff changeset	1617
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1618 struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
78 222238621f18 lindent marty parents: 72 diff changeset	1619
222238621f18 lindent marty parents: 72 diff changeset	1620 if (mtd->sync) {
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1621 mtd->sync(mtd);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1622 }
78 222238621f18 lindent marty parents: 72 diff changeset	1623
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1624 put_mtd_device(mtd);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1625 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1626
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1627
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1628 static void yaffs_MarkSuperBlockDirty(void *vsb)
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1629 {
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1630 struct super_block sb = (struct super_block )vsb;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1631
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1632 T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1633 // if(sb)
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1634 // sb->s_dirt = 1;
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1635 }
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1636
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1637 typedef struct {
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1638 int inband_tags;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1639 int skip_checkpoint_read;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1640 int skip_checkpoint_write;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1641 int no_cache;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1642 } yaffs_options;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1643
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1644 #define MAX_OPT_LEN 20
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1645 static int yaffs_parse_options(yaffs_options options, const char options_str)
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1646 {
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1647 char cur_opt[MAX_OPT_LEN+1];
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1648 int p;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1649 int error = 0;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1650
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1651 /* Parse through the options which is a comma seperated list */
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1652
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1653 while(options_str && *options_str && !error){
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1654 memset(cur_opt,0,MAX_OPT_LEN+1);
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1655 p = 0;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1656
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1657 while(options_str && options_str != ','){
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1658 if(p < MAX_OPT_LEN){
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1659 cur_opt[p] = *options_str;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1660 p++;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1661 }
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1662 options_str++;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1663 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1664
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1665 if(!strcmp(cur_opt,"inband-tags"))
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1666 options->inband_tags = 1;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1667 else if(!strcmp(cur_opt,"no-cache"))
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1668 options->no_cache = 1;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1669 else if(!strcmp(cur_opt,"no-checkpoint-read"))
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1670 options->skip_checkpoint_read = 1;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1671 else if(!strcmp(cur_opt,"no-checkpoint-write"))
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1672 options->skip_checkpoint_write = 1;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1673 else if(!strcmp(cur_opt,"no-checkpoint")){
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1674 options->skip_checkpoint_read = 1;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1675 options->skip_checkpoint_write = 1;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1676 } else {
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1677 printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",cur_opt);
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1678 error = 1;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1679 }
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1680
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1681 }
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1682
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1683 return error;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1684 }
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1685
78 222238621f18 lindent marty parents: 72 diff changeset	1686 static struct super_block *yaffs_internal_read_super(int yaffsVersion,
222238621f18 lindent marty parents: 72 diff changeset	1687 struct super_block *sb,
222238621f18 lindent marty parents: 72 diff changeset	1688 void *data, int silent)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1689 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1690 int nBlocks;
78 222238621f18 lindent marty parents: 72 diff changeset	1691 struct inode *inode = NULL;
222238621f18 lindent marty parents: 72 diff changeset	1692 struct dentry *root;
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	1693 yaffs_Device *dev = 0;
78 222238621f18 lindent marty parents: 72 diff changeset	1694 char devname_buf[BDEVNAME_SIZE + 1];
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1695 struct mtd_info *mtd;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1696 int err;
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1697 char data_str = (char )data;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1698
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1699 yaffs_options options;
78 222238621f18 lindent marty parents: 72 diff changeset	1700
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1701 sb->s_magic = YAFFS_MAGIC;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1702 sb->s_op = &yaffs_super_ops;
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1703 sb->s_flags \|= MS_NOATIME;
78 222238621f18 lindent marty parents: 72 diff changeset	1704
222238621f18 lindent marty parents: 72 diff changeset	1705 if (!sb)
222238621f18 lindent marty parents: 72 diff changeset	1706 printk(KERN_INFO "yaffs: sb is NULL\n");
222238621f18 lindent marty parents: 72 diff changeset	1707 else if (!sb->s_dev)
222238621f18 lindent marty parents: 72 diff changeset	1708 printk(KERN_INFO "yaffs: sb->s_dev is NULL\n");
222238621f18 lindent marty parents: 72 diff changeset	1709 else if (!yaffs_devname(sb, devname_buf))
222238621f18 lindent marty parents: 72 diff changeset	1710 printk(KERN_INFO "yaffs: devname is NULL\n");
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1711 else
78 222238621f18 lindent marty parents: 72 diff changeset	1712 printk(KERN_INFO "yaffs: dev is %d name is \"%s\"\n",
222238621f18 lindent marty parents: 72 diff changeset	1713 sb->s_dev,
222238621f18 lindent marty parents: 72 diff changeset	1714 yaffs_devname(sb, devname_buf));
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1715
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1716 if(!data_str)
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1717 data_str = "";
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1718
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1719 printk(KERN_INFO "yaffs: passed flags \"%s\"\n",data_str);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1720
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1721 memset(&options,0,sizeof(options));
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1722
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1723 if(yaffs_parse_options(&options,data_str)){
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1724 /* Option parsing failed */
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1725 return NULL;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1726 }
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1727
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1728
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1729 sb->s_blocksize = PAGE_CACHE_SIZE;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1730 sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
78 222238621f18 lindent marty parents: 72 diff changeset	1731 T(YAFFS_TRACE_OS, ("yaffs_read_super: Using yaffs%d\n", yaffsVersion));
222238621f18 lindent marty parents: 72 diff changeset	1732 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1733 ("yaffs_read_super: block size %d\n", (int)(sb->s_blocksize)));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1734
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1735 #ifdef CONFIG_YAFFS_DISABLE_WRITE_VERIFY
78 222238621f18 lindent marty parents: 72 diff changeset	1736 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1737 ("yaffs: Write verification disabled. All guarantees "
222238621f18 lindent marty parents: 72 diff changeset	1738 "null and void\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1739 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1740
78 222238621f18 lindent marty parents: 72 diff changeset	1741 T(YAFFS_TRACE_ALWAYS, ("yaffs: Attempting MTD mount on %u.%u, "
222238621f18 lindent marty parents: 72 diff changeset	1742 "\"%s\"\n",
222238621f18 lindent marty parents: 72 diff changeset	1743 MAJOR(sb->s_dev), MINOR(sb->s_dev),
222238621f18 lindent marty parents: 72 diff changeset	1744 yaffs_devname(sb, devname_buf)));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1745
78 222238621f18 lindent marty parents: 72 diff changeset	1746 /* Check it's an mtd device..... */
222238621f18 lindent marty parents: 72 diff changeset	1747 if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
222238621f18 lindent marty parents: 72 diff changeset	1748 return NULL; /* This isn't an mtd device */
222238621f18 lindent marty parents: 72 diff changeset	1749 }
222238621f18 lindent marty parents: 72 diff changeset	1750 /* Get the device */
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1751 mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
78 222238621f18 lindent marty parents: 72 diff changeset	1752 if (!mtd) {
222238621f18 lindent marty parents: 72 diff changeset	1753 T(YAFFS_TRACE_ALWAYS,
222238621f18 lindent marty parents: 72 diff changeset	1754 ("yaffs: MTD device #%u doesn't appear to exist\n",
222238621f18 lindent marty parents: 72 diff changeset	1755 MINOR(sb->s_dev)));
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1756 return NULL;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1757 }
78 222238621f18 lindent marty parents: 72 diff changeset	1758 /* Check it's NAND */
222238621f18 lindent marty parents: 72 diff changeset	1759 if (mtd->type != MTD_NANDFLASH) {
222238621f18 lindent marty parents: 72 diff changeset	1760 T(YAFFS_TRACE_ALWAYS,
222238621f18 lindent marty parents: 72 diff changeset	1761 ("yaffs: MTD device is not NAND it's type %d\n", mtd->type));
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1762 return NULL;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1763 }
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1764
78 222238621f18 lindent marty parents: 72 diff changeset	1765 T(YAFFS_TRACE_OS, (" erase %p\n", mtd->erase));
222238621f18 lindent marty parents: 72 diff changeset	1766 T(YAFFS_TRACE_OS, (" read %p\n", mtd->read));
222238621f18 lindent marty parents: 72 diff changeset	1767 T(YAFFS_TRACE_OS, (" write %p\n", mtd->write));
222238621f18 lindent marty parents: 72 diff changeset	1768 T(YAFFS_TRACE_OS, (" readoob %p\n", mtd->read_oob));
222238621f18 lindent marty parents: 72 diff changeset	1769 T(YAFFS_TRACE_OS, (" writeoob %p\n", mtd->write_oob));
222238621f18 lindent marty parents: 72 diff changeset	1770 T(YAFFS_TRACE_OS, (" block_isbad %p\n", mtd->block_isbad));
222238621f18 lindent marty parents: 72 diff changeset	1771 T(YAFFS_TRACE_OS, (" block_markbad %p\n", mtd->block_markbad));
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1772 T(YAFFS_TRACE_OS, (" %s %d\n", WRITE_SIZE_STR, WRITE_SIZE(mtd)));
78 222238621f18 lindent marty parents: 72 diff changeset	1773 T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
222238621f18 lindent marty parents: 72 diff changeset	1774 T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
222238621f18 lindent marty parents: 72 diff changeset	1775 T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1776
112 ea18b2c034e6 Fix conditional charles parents: 111 diff changeset	1777 #ifdef CONFIG_YAFFS_AUTO_YAFFS2
111 43d9629a47ec Add yaffs2 autoselection charles parents: 109 diff changeset	1778
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1779 if (yaffsVersion == 1 &&
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1780 WRITE_SIZE(mtd) >= 2048) {
111 43d9629a47ec Add yaffs2 autoselection charles parents: 109 diff changeset	1781 T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
43d9629a47ec Add yaffs2 autoselection charles parents: 109 diff changeset	1782 yaffsVersion = 2;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1783 }
f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1784
143 5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	1785 /* Added NCB 26/5/2006 for completeness */
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1786 if (yaffsVersion == 2 &&
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1787 !options.inband_tags &&
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1788 WRITE_SIZE(mtd) == 512){
143 5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	1789 T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	1790 yaffsVersion = 1;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1791 }
143 5817b3173bfd Add Nick's yaffs1 autoselection charles parents: 139 diff changeset	1792
111 43d9629a47ec Add yaffs2 autoselection charles parents: 109 diff changeset	1793 #endif
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1794
78 222238621f18 lindent marty parents: 72 diff changeset	1795 if (yaffsVersion == 2) {
222238621f18 lindent marty parents: 72 diff changeset	1796 /* Check for version 2 style functions */
222238621f18 lindent marty parents: 72 diff changeset	1797 if (!mtd->erase \|\|
222238621f18 lindent marty parents: 72 diff changeset	1798 !mtd->block_isbad \|\|
222238621f18 lindent marty parents: 72 diff changeset	1799 !mtd->block_markbad \|\|
222238621f18 lindent marty parents: 72 diff changeset	1800 !mtd->read \|\|
222238621f18 lindent marty parents: 72 diff changeset	1801 !mtd->write \|\|
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1802 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1803 !mtd->read_oob \|\| !mtd->write_oob) {
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1804 #else
78 222238621f18 lindent marty parents: 72 diff changeset	1805 !mtd->write_ecc \|\|
222238621f18 lindent marty parents: 72 diff changeset	1806 !mtd->read_ecc \|\| !mtd->read_oob \|\| !mtd->write_oob) {
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1807 #endif
78 222238621f18 lindent marty parents: 72 diff changeset	1808 T(YAFFS_TRACE_ALWAYS,
222238621f18 lindent marty parents: 72 diff changeset	1809 ("yaffs: MTD device does not support required "
222238621f18 lindent marty parents: 72 diff changeset	1810 "functions\n"));;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1811 return NULL;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1812 }
78 222238621f18 lindent marty parents: 72 diff changeset	1813
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1814 if ((WRITE_SIZE(mtd) < YAFFS_MIN_YAFFS2_CHUNK_SIZE \|\|
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1815 mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) &&
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1816 !options.inband_tags) {
78 222238621f18 lindent marty parents: 72 diff changeset	1817 T(YAFFS_TRACE_ALWAYS,
130 460ef77b6385 Fix a couple of mistakes in TRACE/Error messages. Update copyright date. wookey parents: 128 diff changeset	1818 ("yaffs: MTD device does not have the "
78 222238621f18 lindent marty parents: 72 diff changeset	1819 "right page sizes\n"));
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1820 return NULL;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1821 }
78 222238621f18 lindent marty parents: 72 diff changeset	1822 } else {
222238621f18 lindent marty parents: 72 diff changeset	1823 /* Check for V1 style functions */
222238621f18 lindent marty parents: 72 diff changeset	1824 if (!mtd->erase \|\|
222238621f18 lindent marty parents: 72 diff changeset	1825 !mtd->read \|\|
222238621f18 lindent marty parents: 72 diff changeset	1826 !mtd->write \|\|
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1827 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1828 !mtd->read_oob \|\| !mtd->write_oob) {
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1829 #else
78 222238621f18 lindent marty parents: 72 diff changeset	1830 !mtd->write_ecc \|\|
222238621f18 lindent marty parents: 72 diff changeset	1831 !mtd->read_ecc \|\| !mtd->read_oob \|\| !mtd->write_oob) {
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1832 #endif
78 222238621f18 lindent marty parents: 72 diff changeset	1833 T(YAFFS_TRACE_ALWAYS,
222238621f18 lindent marty parents: 72 diff changeset	1834 ("yaffs: MTD device does not support required "
222238621f18 lindent marty parents: 72 diff changeset	1835 "functions\n"));;
222238621f18 lindent marty parents: 72 diff changeset	1836 return NULL;
222238621f18 lindent marty parents: 72 diff changeset	1837 }
222238621f18 lindent marty parents: 72 diff changeset	1838
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1839 if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK \|\|
78 222238621f18 lindent marty parents: 72 diff changeset	1840 mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
222238621f18 lindent marty parents: 72 diff changeset	1841 T(YAFFS_TRACE_ALWAYS,
222238621f18 lindent marty parents: 72 diff changeset	1842 ("yaffs: MTD device does not support have the "
222238621f18 lindent marty parents: 72 diff changeset	1843 "right page sizes\n"));
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1844 return NULL;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1845 }
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1846 }
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1847
78 222238621f18 lindent marty parents: 72 diff changeset	1848 /* OK, so if we got here, we have an MTD that's NAND and looks
222238621f18 lindent marty parents: 72 diff changeset	1849 * like it has the right capabilities
222238621f18 lindent marty parents: 72 diff changeset	1850 * Set the yaffs_Device up for mtd
222238621f18 lindent marty parents: 72 diff changeset	1851 */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1852
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1853 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	1854 sb->s_fs_info = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1855 #else
78 222238621f18 lindent marty parents: 72 diff changeset	1856 sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1857 #endif
78 222238621f18 lindent marty parents: 72 diff changeset	1858 if (!dev) {
222238621f18 lindent marty parents: 72 diff changeset	1859 /* Deep shit could not allocate device structure */
222238621f18 lindent marty parents: 72 diff changeset	1860 T(YAFFS_TRACE_ALWAYS,
222238621f18 lindent marty parents: 72 diff changeset	1861 ("yaffs_read_super: Failed trying to allocate "
222238621f18 lindent marty parents: 72 diff changeset	1862 "yaffs_Device. \n"));
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1863 return NULL;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1864 }
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1865
78 222238621f18 lindent marty parents: 72 diff changeset	1866 memset(dev, 0, sizeof(yaffs_Device));
222238621f18 lindent marty parents: 72 diff changeset	1867 dev->genericDevice = mtd;
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1868 dev->name = mtd->name;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1869
78 222238621f18 lindent marty parents: 72 diff changeset	1870 /* Set up the memory size parameters.... */
222238621f18 lindent marty parents: 72 diff changeset	1871
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1872 nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1873 dev->startBlock = 0;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1874 dev->endBlock = nBlocks - 1;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1875 dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1876 dev->totalBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1877 dev->nReservedBlocks = 5;
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1878 dev->nShortOpCaches = (options.no_cache) ? 0 : 10;
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1879 dev->inbandTags = options.inband_tags;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1880
78 222238621f18 lindent marty parents: 72 diff changeset	1881 /* ... and the functions. */
222238621f18 lindent marty parents: 72 diff changeset	1882 if (yaffsVersion == 2) {
222238621f18 lindent marty parents: 72 diff changeset	1883 dev->writeChunkWithTagsToNAND =
222238621f18 lindent marty parents: 72 diff changeset	1884 nandmtd2_WriteChunkWithTagsToNAND;
222238621f18 lindent marty parents: 72 diff changeset	1885 dev->readChunkWithTagsFromNAND =
222238621f18 lindent marty parents: 72 diff changeset	1886 nandmtd2_ReadChunkWithTagsFromNAND;
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1887 dev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1888 dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1889 dev->spareBuffer = YMALLOC(mtd->oobsize);
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1890 dev->isYaffs2 = 1;
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1891 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1892 dev->totalBytesPerChunk = mtd->writesize;
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1893 dev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1894 #else
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	1895 dev->totalBytesPerChunk = mtd->oobblock;
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1896 dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1897 #endif
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1898 nBlocks = mtd->size / mtd->erasesize;
137 62488e7b581f Fix some checkpoint stuff, add qsort charles parents: 135 diff changeset	1899
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1900 dev->startBlock = 0;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1901 dev->endBlock = nBlocks - 1;
78 222238621f18 lindent marty parents: 72 diff changeset	1902 } else {
185 fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1903 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1904 /* use the MTD interface in yaffs_mtdif1.c */
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1905 dev->writeChunkWithTagsToNAND =
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1906 nandmtd1_WriteChunkWithTagsToNAND;
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1907 dev->readChunkWithTagsFromNAND =
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1908 nandmtd1_ReadChunkWithTagsFromNAND;
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1909 dev->markNANDBlockBad = nandmtd1_MarkNANDBlockBad;
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1910 dev->queryNANDBlock = nandmtd1_QueryNANDBlock;
fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1911 #else
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1912 dev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1913 dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
185 fa4e74c5013d Rolling in Ians and other changes charles parents: 182 diff changeset	1914 #endif
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1915 dev->isYaffs2 = 0;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1916 }
78 222238621f18 lindent marty parents: 72 diff changeset	1917 /* ... and common functions */
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1918 dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1919 dev->initialiseNAND = nandmtd_InitialiseNAND;
78 222238621f18 lindent marty parents: 72 diff changeset	1920
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1921 dev->putSuperFunc = yaffs_MTDPutSuper;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1922
135 fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1923 dev->superBlock = (void *)sb;
fcc0b2718f67 Add non-partitioned checkpointing charles parents: 131 diff changeset	1924 dev->markSuperBlockDirty = yaffs_MarkSuperBlockDirty;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1925
78 222238621f18 lindent marty parents: 72 diff changeset	1926
63 d7b5de6ac891 newconfig: use YAFFS_DOES_ECC instead of USE_NANDECC luc parents: 61 diff changeset	1927 #ifndef CONFIG_YAFFS_DOES_ECC
61 c2fdd493a8f8 Adapt the code structure after removing of the yaffsram support. luc parents: 60 diff changeset	1928 dev->useNANDECC = 1;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1929 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1930
107 f5445121de97 Hook wide tnode support into Linux charles parents: 102 diff changeset	1931 #ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES
f5445121de97 Hook wide tnode support into Linux charles parents: 102 diff changeset	1932 dev->wideTnodesDisabled = 1;
f5445121de97 Hook wide tnode support into Linux charles parents: 102 diff changeset	1933 #endif
f5445121de97 Hook wide tnode support into Linux charles parents: 102 diff changeset	1934
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1935 dev->skipCheckpointRead = options.skip_checkpoint_read;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	1936 dev->skipCheckpointWrite = options.skip_checkpoint_write;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1937
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	1938 /* we assume this is protected by lock_kernel() in mount/umount */
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	1939 ylist_add_tail(&dev->devList, &yaffs_dev_list);
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	1940
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1941 init_MUTEX(&dev->grossLock);
78 222238621f18 lindent marty parents: 72 diff changeset	1942
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1943 yaffs_GrossLock(dev);
78 222238621f18 lindent marty parents: 72 diff changeset	1944
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1945 err = yaffs_GutsInitialise(dev);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1946
78 222238621f18 lindent marty parents: 72 diff changeset	1947 T(YAFFS_TRACE_OS,
222238621f18 lindent marty parents: 72 diff changeset	1948 ("yaffs_read_super: guts initialised %s\n",
222238621f18 lindent marty parents: 72 diff changeset	1949 (err == YAFFS_OK) ? "OK" : "FAILED"));
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	1950
109 1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1951 /* Release lock before yaffs_get_inode() */
1cbbe1e003ac Apply Reed's deadlocking fix (manually applied) charles parents: 107 diff changeset	1952 yaffs_GrossUnlock(dev);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1953
78 222238621f18 lindent marty parents: 72 diff changeset	1954 /* Create root inode */
222238621f18 lindent marty parents: 72 diff changeset	1955 if (err == YAFFS_OK)
222238621f18 lindent marty parents: 72 diff changeset	1956 inode = yaffs_get_inode(sb, S_IFDIR \| 0755, 0,
222238621f18 lindent marty parents: 72 diff changeset	1957 yaffs_Root(dev));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1958
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1959 if (!inode)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1960 return NULL;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1961
78 222238621f18 lindent marty parents: 72 diff changeset	1962 inode->i_op = &yaffs_dir_inode_operations;
222238621f18 lindent marty parents: 72 diff changeset	1963 inode->i_fop = &yaffs_dir_operations;
222238621f18 lindent marty parents: 72 diff changeset	1964
222238621f18 lindent marty parents: 72 diff changeset	1965 T(YAFFS_TRACE_OS, ("yaffs_read_super: got root inode\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1966
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1967 root = d_alloc_root(inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1968
78 222238621f18 lindent marty parents: 72 diff changeset	1969 T(YAFFS_TRACE_OS, ("yaffs_read_super: d_alloc_root done\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1970
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1971 if (!root) {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1972 iput(inode);
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1973 return NULL;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1974 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1975 sb->s_root = root;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1976
78 222238621f18 lindent marty parents: 72 diff changeset	1977 T(YAFFS_TRACE_OS, ("yaffs_read_super: done\n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1978 return sb;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1979 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1980
34 95f802b86a29 Move the internals read_super() functions near the declaration of luc parents: 31 diff changeset	1981
95f802b86a29 Move the internals read_super() functions near the declaration of luc parents: 31 diff changeset	1982 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	1983 static int yaffs_internal_read_super_mtd(struct super_block sb, void data,
222238621f18 lindent marty parents: 72 diff changeset	1984 int silent)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1985 {
98 0da5cd5a9ac0 Patch from Sergey Kubushyn [ksi@koi8.net] marty parents: 97 diff changeset	1986 return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	1987 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	1988
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1989 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1990 static int yaffs_read_super(struct file_system_type *fs,
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1991 int flags, const char *dev_name,
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1992 void data, struct vfsmount mnt)
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1993 {
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1994
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1995 return get_sb_bdev(fs, flags, dev_name, data,
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1996 yaffs_internal_read_super_mtd, mnt);
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1997 }
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	1998 #else
78 222238621f18 lindent marty parents: 72 diff changeset	1999 static struct super_block yaffs_read_super(struct file_system_type fs,
222238621f18 lindent marty parents: 72 diff changeset	2000 int flags, const char *dev_name,
222238621f18 lindent marty parents: 72 diff changeset	2001 void *data)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2002 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2003
78 222238621f18 lindent marty parents: 72 diff changeset	2004 return get_sb_bdev(fs, flags, dev_name, data,
222238621f18 lindent marty parents: 72 diff changeset	2005 yaffs_internal_read_super_mtd);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2006 }
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2007 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2008
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2009 static struct file_system_type yaffs_fs_type = {
78 222238621f18 lindent marty parents: 72 diff changeset	2010 .owner = THIS_MODULE,
222238621f18 lindent marty parents: 72 diff changeset	2011 .name = "yaffs",
222238621f18 lindent marty parents: 72 diff changeset	2012 .get_sb = yaffs_read_super,
222238621f18 lindent marty parents: 72 diff changeset	2013 .kill_sb = kill_block_super,
222238621f18 lindent marty parents: 72 diff changeset	2014 .fs_flags = FS_REQUIRES_DEV,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2015 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2016 #else
78 222238621f18 lindent marty parents: 72 diff changeset	2017 static struct super_block yaffs_read_super(struct super_block sb, void *data,
222238621f18 lindent marty parents: 72 diff changeset	2018 int silent)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2019 {
78 222238621f18 lindent marty parents: 72 diff changeset	2020 return yaffs_internal_read_super(1, sb, data, silent);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2021 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2022
78 222238621f18 lindent marty parents: 72 diff changeset	2023 static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super,
222238621f18 lindent marty parents: 72 diff changeset	2024 FS_REQUIRES_DEV);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2025 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2026
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2027
51 6a3faa645b1b Remove CONFIG_YAFFS_USE_CHUNK_SIZE marty parents: 47 diff changeset	2028 #ifdef CONFIG_YAFFS_YAFFS2
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2029
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2030 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
78 222238621f18 lindent marty parents: 72 diff changeset	2031 static int yaffs2_internal_read_super_mtd(struct super_block sb, void data,
222238621f18 lindent marty parents: 72 diff changeset	2032 int silent)
34 95f802b86a29 Move the internals read_super() functions near the declaration of luc parents: 31 diff changeset	2033 {
98 0da5cd5a9ac0 Patch from Sergey Kubushyn [ksi@koi8.net] marty parents: 97 diff changeset	2034 return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL;
34 95f802b86a29 Move the internals read_super() functions near the declaration of luc parents: 31 diff changeset	2035 }
95f802b86a29 Move the internals read_super() functions near the declaration of luc parents: 31 diff changeset	2036
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2037 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2038 static int yaffs2_read_super(struct file_system_type *fs,
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2039 int flags, const char dev_name, void data,
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2040 struct vfsmount *mnt)
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2041 {
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2042 return get_sb_bdev(fs, flags, dev_name, data,
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2043 yaffs2_internal_read_super_mtd, mnt);
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2044 }
212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2045 #else
78 222238621f18 lindent marty parents: 72 diff changeset	2046 static struct super_block yaffs2_read_super(struct file_system_type fs,
222238621f18 lindent marty parents: 72 diff changeset	2047 int flags, const char *dev_name,
222238621f18 lindent marty parents: 72 diff changeset	2048 void *data)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2049 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2050
78 222238621f18 lindent marty parents: 72 diff changeset	2051 return get_sb_bdev(fs, flags, dev_name, data,
222238621f18 lindent marty parents: 72 diff changeset	2052 yaffs2_internal_read_super_mtd);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2053 }
149 212486fd066b Interworking with 2.6.18 kernel enabled vwool parents: 145 diff changeset	2054 #endif
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2055
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2056 static struct file_system_type yaffs2_fs_type = {
78 222238621f18 lindent marty parents: 72 diff changeset	2057 .owner = THIS_MODULE,
222238621f18 lindent marty parents: 72 diff changeset	2058 .name = "yaffs2",
222238621f18 lindent marty parents: 72 diff changeset	2059 .get_sb = yaffs2_read_super,
222238621f18 lindent marty parents: 72 diff changeset	2060 .kill_sb = kill_block_super,
222238621f18 lindent marty parents: 72 diff changeset	2061 .fs_flags = FS_REQUIRES_DEV,
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2062 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2063 #else
78 222238621f18 lindent marty parents: 72 diff changeset	2064 static struct super_block yaffs2_read_super(struct super_block sb,
222238621f18 lindent marty parents: 72 diff changeset	2065 void *data, int silent)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2066 {
78 222238621f18 lindent marty parents: 72 diff changeset	2067 return yaffs_internal_read_super(2, sb, data, silent);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2068 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2069
78 222238621f18 lindent marty parents: 72 diff changeset	2070 static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super,
222238621f18 lindent marty parents: 72 diff changeset	2071 FS_REQUIRES_DEV);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2072 #endif
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2073
78 222238621f18 lindent marty parents: 72 diff changeset	2074 #endif /* CONFIG_YAFFS_YAFFS2 */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2075
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2076 static struct proc_dir_entry *my_proc_entry;
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2077
78 222238621f18 lindent marty parents: 72 diff changeset	2078 static char yaffs_dump_dev(char buf, yaffs_Device * dev)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2079 {
78 222238621f18 lindent marty parents: 72 diff changeset	2080 buf += sprintf(buf, "startBlock......... %d\n", dev->startBlock);
222238621f18 lindent marty parents: 72 diff changeset	2081 buf += sprintf(buf, "endBlock........... %d\n", dev->endBlock);
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	2082 buf += sprintf(buf, "totalBytesPerChunk. %d\n", dev->totalBytesPerChunk);
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2083 buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk);
78 222238621f18 lindent marty parents: 72 diff changeset	2084 buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits);
222238621f18 lindent marty parents: 72 diff changeset	2085 buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize);
222238621f18 lindent marty parents: 72 diff changeset	2086 buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks);
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2087 buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->nReservedBlocks);
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2088 buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint);
78 222238621f18 lindent marty parents: 72 diff changeset	2089 buf += sprintf(buf, "nTnodesCreated..... %d\n", dev->nTnodesCreated);
222238621f18 lindent marty parents: 72 diff changeset	2090 buf += sprintf(buf, "nFreeTnodes........ %d\n", dev->nFreeTnodes);
222238621f18 lindent marty parents: 72 diff changeset	2091 buf += sprintf(buf, "nObjectsCreated.... %d\n", dev->nObjectsCreated);
222238621f18 lindent marty parents: 72 diff changeset	2092 buf += sprintf(buf, "nFreeObjects....... %d\n", dev->nFreeObjects);
222238621f18 lindent marty parents: 72 diff changeset	2093 buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks);
222238621f18 lindent marty parents: 72 diff changeset	2094 buf += sprintf(buf, "nPageWrites........ %d\n", dev->nPageWrites);
222238621f18 lindent marty parents: 72 diff changeset	2095 buf += sprintf(buf, "nPageReads......... %d\n", dev->nPageReads);
222238621f18 lindent marty parents: 72 diff changeset	2096 buf += sprintf(buf, "nBlockErasures..... %d\n", dev->nBlockErasures);
222238621f18 lindent marty parents: 72 diff changeset	2097 buf += sprintf(buf, "nGCCopies.......... %d\n", dev->nGCCopies);
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	2098 buf += sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	2099 buf += sprintf(buf, "passiveGCs......... %d\n",
78 222238621f18 lindent marty parents: 72 diff changeset	2100 dev->passiveGarbageCollections);
222238621f18 lindent marty parents: 72 diff changeset	2101 buf += sprintf(buf, "nRetriedWrites..... %d\n", dev->nRetriedWrites);
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2102 buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->nShortOpCaches);
78 222238621f18 lindent marty parents: 72 diff changeset	2103 buf += sprintf(buf, "nRetireBlocks...... %d\n", dev->nRetiredBlocks);
222238621f18 lindent marty parents: 72 diff changeset	2104 buf += sprintf(buf, "eccFixed........... %d\n", dev->eccFixed);
222238621f18 lindent marty parents: 72 diff changeset	2105 buf += sprintf(buf, "eccUnfixed......... %d\n", dev->eccUnfixed);
222238621f18 lindent marty parents: 72 diff changeset	2106 buf += sprintf(buf, "tagsEccFixed....... %d\n", dev->tagsEccFixed);
222238621f18 lindent marty parents: 72 diff changeset	2107 buf += sprintf(buf, "tagsEccUnfixed..... %d\n", dev->tagsEccUnfixed);
222238621f18 lindent marty parents: 72 diff changeset	2108 buf += sprintf(buf, "cacheHits.......... %d\n", dev->cacheHits);
222238621f18 lindent marty parents: 72 diff changeset	2109 buf += sprintf(buf, "nDeletedFiles...... %d\n", dev->nDeletedFiles);
222238621f18 lindent marty parents: 72 diff changeset	2110 buf += sprintf(buf, "nUnlinkedFiles..... %d\n", dev->nUnlinkedFiles);
222238621f18 lindent marty parents: 72 diff changeset	2111 buf +=
222238621f18 lindent marty parents: 72 diff changeset	2112 sprintf(buf, "nBackgroudDeletions %d\n", dev->nBackgroundDeletions);
222238621f18 lindent marty parents: 72 diff changeset	2113 buf += sprintf(buf, "useNANDECC......... %d\n", dev->useNANDECC);
222238621f18 lindent marty parents: 72 diff changeset	2114 buf += sprintf(buf, "isYaffs2........... %d\n", dev->isYaffs2);
211 fad21fd1971d Check in inband tags, some extra yaffs direct functions and some other changes charles parents: 205 diff changeset	2115 buf += sprintf(buf, "inbandTags......... %d\n", dev->inbandTags);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2116
78 222238621f18 lindent marty parents: 72 diff changeset	2117 return buf;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2118 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2119
78 222238621f18 lindent marty parents: 72 diff changeset	2120 static int yaffs_proc_read(char *page,
222238621f18 lindent marty parents: 72 diff changeset	2121 char **start,
222238621f18 lindent marty parents: 72 diff changeset	2122 off_t offset, int count, int eof, void data)
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2123 {
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	2124 struct ylist_head *item;
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2125 char *buf = page;
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2126 int step = offset;
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2127 int n = 0;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2128
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2129 /* Get proc_file_read() to step 'offset' by one on each sucessive call.
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2130 * We use 'offset' (*ppos) to indicate where we are in devList.
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2131 * This also assumes the user has posted a read buffer large
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2132 * enough to hold the complete output; but that's life in /proc.
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2133 */
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2134
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2135 (int )start = 1;
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2136
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2137 /* Print header first */
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2138 if (step == 0) {
78 222238621f18 lindent marty parents: 72 diff changeset	2139 buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__
222238621f18 lindent marty parents: 72 diff changeset	2140 "\n%s\n%s\n", yaffs_fs_c_version,
222238621f18 lindent marty parents: 72 diff changeset	2141 yaffs_guts_c_version);
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2142 }
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2143
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2144 /* hold lock_kernel while traversing yaffs_dev_list */
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2145 lock_kernel();
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2146
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2147 /* Locate and print the Nth entry. Order N-squared but N is small. */
217 6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	2148 ylist_for_each(item, &yaffs_dev_list) {
6dbe40ae9e54 Some cleanups, Linux 2.6.25 handling, fix handing of root permissions charles parents: 211 diff changeset	2149 yaffs_Device *dev = ylist_entry(item, yaffs_Device, devList);
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2150 if (n < step) {
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2151 n++;
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2152 continue;
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2153 }
78 222238621f18 lindent marty parents: 72 diff changeset	2154 buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->name);
29 bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2155 buf = yaffs_dump_dev(buf, dev);
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2156 break;
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2157 }
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2158 unlock_kernel();
bd762956951e Allow /proc/yaffs to handle multiple fs charles parents: 28 diff changeset	2159
78 222238621f18 lindent marty parents: 72 diff changeset	2160 return buf - page < count ? buf - page : count;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2161 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2162
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2163 /**
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2164 * Set the verbosity of the warnings and error messages.
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2165 *
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2166 * Note that the names can only be a..z or _ with the current code.
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2167 */
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2168
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2169 static struct {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2170 char *mask_name;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2171 unsigned mask_bitfield;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2172 } mask_flags[] = {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2173 {"allocate", YAFFS_TRACE_ALLOCATE},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2174 {"always", YAFFS_TRACE_ALWAYS},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2175 {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2176 {"buffers", YAFFS_TRACE_BUFFERS},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2177 {"bug", YAFFS_TRACE_BUG},
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2178 {"checkpt", YAFFS_TRACE_CHECKPOINT},
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2179 {"deletion", YAFFS_TRACE_DELETION},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2180 {"erase", YAFFS_TRACE_ERASE},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2181 {"error", YAFFS_TRACE_ERROR},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2182 {"gc_detail", YAFFS_TRACE_GC_DETAIL},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2183 {"gc", YAFFS_TRACE_GC},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2184 {"mtd", YAFFS_TRACE_MTD},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2185 {"nandaccess", YAFFS_TRACE_NANDACCESS},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2186 {"os", YAFFS_TRACE_OS},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2187 {"scan_debug", YAFFS_TRACE_SCAN_DEBUG},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2188 {"scan", YAFFS_TRACE_SCAN},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2189 {"tracing", YAFFS_TRACE_TRACING},
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2190
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2191 {"verify", YAFFS_TRACE_VERIFY},
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2192 {"verify_nand", YAFFS_TRACE_VERIFY_NAND},
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2193 {"verify_full", YAFFS_TRACE_VERIFY_FULL},
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2194 {"verify_all", YAFFS_TRACE_VERIFY_ALL},
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2195
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2196 {"write", YAFFS_TRACE_WRITE},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2197 {"all", 0xffffffff},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2198 {"none", 0},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2199 {NULL, 0},
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2200 };
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2201
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2202 #define MAX_MASK_NAME_LENGTH 40
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2203 static int yaffs_proc_write(struct file file, const char buf,
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2204 unsigned long count, void *data)
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2205 {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2206 unsigned rg = 0, mask_bitfield;
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2207 char *end;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2208 char *mask_name;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	2209 const char *x;
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2210 char substring[MAX_MASK_NAME_LENGTH+1];
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2211 int i;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2212 int done = 0;
172 27d73e470d9d Update for Linux 2.6.19 support charles parents: 171 diff changeset	2213 int add, len = 0;
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2214 int pos = 0;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2215
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2216 rg = yaffs_traceMask;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2217
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2218 while (!done && (pos < count)) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2219 done = 1;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2220 while ((pos < count) && isspace(buf[pos])) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2221 pos++;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2222 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2223
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2224 switch (buf[pos]) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2225 case '+':
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2226 case '-':
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2227 case '=':
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2228 add = buf[pos];
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2229 pos++;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2230 break;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2231
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2232 default:
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2233 add = ' ';
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2234 break;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2235 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2236 mask_name = NULL;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	2237
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2238 mask_bitfield = simple_strtoul(buf + pos, &end, 0);
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2239 if (end > buf + pos) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2240 mask_name = "numeral";
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2241 len = end - (buf + pos);
194 d3294d27d875 Fix infinite loop when parsing numeric trace flags written to /proc/yaffs. imcd parents: 185 diff changeset	2242 pos += len;
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2243 done = 0;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2244 } else {
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	2245 for(x = buf + pos, i = 0;
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2246 (x == '_' \|\| (x >='a' && *x <= 'z')) &&
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2247 i <MAX_MASK_NAME_LENGTH; x++, i++, pos++)
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2248 substring[i] = *x;
ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2249 substring[i] = '\0';
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	2250
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2251 for (i = 0; mask_flags[i].mask_name != NULL; i++) {
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2252 if(strcmp(substring,mask_flags[i].mask_name) == 0){
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2253 mask_name = mask_flags[i].mask_name;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2254 mask_bitfield = mask_flags[i].mask_bitfield;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2255 done = 0;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2256 break;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2257 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2258 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2259 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2260
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2261 if (mask_name != NULL) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2262 done = 0;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2263 switch(add) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2264 case '-':
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2265 rg &= ~mask_bitfield;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2266 break;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2267 case '+':
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2268 rg \|= mask_bitfield;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2269 break;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2270 case '=':
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2271 rg = mask_bitfield;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2272 break;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2273 default:
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2274 rg \|= mask_bitfield;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2275 break;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2276 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2277 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2278 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2279
171 52ba5731a251 Add Phils checkpoint configuration charles parents: 154 diff changeset	2280 yaffs_traceMask = rg \| YAFFS_TRACE_ALWAYS;
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	2281
182 ebfd69da1173 Adding checkpoint and robustness improvements charles parents: 181 diff changeset	2282 printk("new trace = 0x%08X\n",yaffs_traceMask);
205 f95fdc6123fb Cleanup patch - Remove all trailing whitespace and fix a few typos. wookey parents: 203 diff changeset	2283
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2284 if (rg & YAFFS_TRACE_ALWAYS) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2285 for (i = 0; mask_flags[i].mask_name != NULL; i++) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2286 char flag;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2287 flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-';
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2288 printk("%c%s\n", flag, mask_flags[i].mask_name);
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2289 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2290 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2291
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2292 return count;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2293 }
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2294
78 222238621f18 lindent marty parents: 72 diff changeset	2295 /* Stuff to handle installation of file systems */
222238621f18 lindent marty parents: 72 diff changeset	2296 struct file_system_to_install {
222238621f18 lindent marty parents: 72 diff changeset	2297 struct file_system_type *fst;
222238621f18 lindent marty parents: 72 diff changeset	2298 int installed;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2299 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2300
78 222238621f18 lindent marty parents: 72 diff changeset	2301 static struct file_system_to_install fs_to_install[] = {
86 9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	2302 //#ifdef CONFIG_YAFFS_YAFFS1
78 222238621f18 lindent marty parents: 72 diff changeset	2303 {&yaffs_fs_type, 0},
86 9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	2304 //#endif
9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	2305 //#ifdef CONFIG_YAFFS_YAFFS2
78 222238621f18 lindent marty parents: 72 diff changeset	2306 {&yaffs2_fs_type, 0},
86 9c9fd9831cf1 Fix rename over problem charles parents: 78 diff changeset	2307 //#endif
78 222238621f18 lindent marty parents: 72 diff changeset	2308 {NULL, 0}
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2309 };
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2310
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2311 static int __init init_yaffs_fs(void)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2312 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2313 int error = 0;
78 222238621f18 lindent marty parents: 72 diff changeset	2314 struct file_system_to_install *fsinst;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2315
78 222238621f18 lindent marty parents: 72 diff changeset	2316 T(YAFFS_TRACE_ALWAYS,
222238621f18 lindent marty parents: 72 diff changeset	2317 ("yaffs " __DATE__ " " __TIME__ " Installing. \n"));
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2318
78 222238621f18 lindent marty parents: 72 diff changeset	2319 /* Install the proc_fs entry */
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2320 my_proc_entry = create_proc_entry("yaffs",
78 222238621f18 lindent marty parents: 72 diff changeset	2321 S_IRUGO \| S_IFREG,
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	2322 YPROC_ROOT);
118 5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2323
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2324 if (my_proc_entry) {
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2325 my_proc_entry->write_proc = yaffs_proc_write;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2326 my_proc_entry->read_proc = yaffs_proc_read;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2327 my_proc_entry->data = NULL;
5f0adbb370c9 Add /proc interface for modifying debugging trace flags, from John M Cavallo. tpoynor parents: 116 diff changeset	2328 } else {
78 222238621f18 lindent marty parents: 72 diff changeset	2329 return -ENOMEM;
222238621f18 lindent marty parents: 72 diff changeset	2330 }
222238621f18 lindent marty parents: 72 diff changeset	2331
222238621f18 lindent marty parents: 72 diff changeset	2332 /* Now add the file system entries */
222238621f18 lindent marty parents: 72 diff changeset	2333
222238621f18 lindent marty parents: 72 diff changeset	2334 fsinst = fs_to_install;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2335
78 222238621f18 lindent marty parents: 72 diff changeset	2336 while (fsinst->fst && !error) {
222238621f18 lindent marty parents: 72 diff changeset	2337 error = register_filesystem(fsinst->fst);
222238621f18 lindent marty parents: 72 diff changeset	2338 if (!error) {
222238621f18 lindent marty parents: 72 diff changeset	2339 fsinst->installed = 1;
222238621f18 lindent marty parents: 72 diff changeset	2340 }
222238621f18 lindent marty parents: 72 diff changeset	2341 fsinst++;
222238621f18 lindent marty parents: 72 diff changeset	2342 }
222238621f18 lindent marty parents: 72 diff changeset	2343
222238621f18 lindent marty parents: 72 diff changeset	2344 /* Any errors? uninstall */
222238621f18 lindent marty parents: 72 diff changeset	2345 if (error) {
222238621f18 lindent marty parents: 72 diff changeset	2346 fsinst = fs_to_install;
222238621f18 lindent marty parents: 72 diff changeset	2347
222238621f18 lindent marty parents: 72 diff changeset	2348 while (fsinst->fst) {
222238621f18 lindent marty parents: 72 diff changeset	2349 if (fsinst->installed) {
222238621f18 lindent marty parents: 72 diff changeset	2350 unregister_filesystem(fsinst->fst);
222238621f18 lindent marty parents: 72 diff changeset	2351 fsinst->installed = 0;
222238621f18 lindent marty parents: 72 diff changeset	2352 }
222238621f18 lindent marty parents: 72 diff changeset	2353 fsinst++;
222238621f18 lindent marty parents: 72 diff changeset	2354 }
222238621f18 lindent marty parents: 72 diff changeset	2355 }
222238621f18 lindent marty parents: 72 diff changeset	2356
222238621f18 lindent marty parents: 72 diff changeset	2357 return error;
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2358 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2359
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2360 static void __exit exit_yaffs_fs(void)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2361 {
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2362
78 222238621f18 lindent marty parents: 72 diff changeset	2363 struct file_system_to_install *fsinst;
222238621f18 lindent marty parents: 72 diff changeset	2364
222238621f18 lindent marty parents: 72 diff changeset	2365 T(YAFFS_TRACE_ALWAYS, ("yaffs " __DATE__ " " __TIME__
222238621f18 lindent marty parents: 72 diff changeset	2366 " removing. \n"));
222238621f18 lindent marty parents: 72 diff changeset	2367
219 472c51d85ef1 Fix compilation on Linux 2.6.26, fix compilation warnings charles parents: 217 diff changeset	2368 remove_proc_entry("yaffs", YPROC_ROOT);
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2369
78 222238621f18 lindent marty parents: 72 diff changeset	2370 fsinst = fs_to_install;
222238621f18 lindent marty parents: 72 diff changeset	2371
222238621f18 lindent marty parents: 72 diff changeset	2372 while (fsinst->fst) {
222238621f18 lindent marty parents: 72 diff changeset	2373 if (fsinst->installed) {
222238621f18 lindent marty parents: 72 diff changeset	2374 unregister_filesystem(fsinst->fst);
222238621f18 lindent marty parents: 72 diff changeset	2375 fsinst->installed = 0;
222238621f18 lindent marty parents: 72 diff changeset	2376 }
222238621f18 lindent marty parents: 72 diff changeset	2377 fsinst++;
222238621f18 lindent marty parents: 72 diff changeset	2378 }
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2379
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2380 }
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2381
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2382 module_init(init_yaffs_fs)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2383 module_exit(exit_yaffs_fs)
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2384
ddfefbbf40d3 * empty log message * charles parents: diff changeset	2385 MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
130 460ef77b6385 Fix a couple of mistakes in TRACE/Error messages. Update copyright date. wookey parents: 128 diff changeset	2386 MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2006");
7 ddfefbbf40d3 * empty log message * charles parents: diff changeset	2387 MODULE_LICENSE("GPL");

Mercurial > yaffs-ecoscentric

annotate yaffs_fs.c @ 219:472c51d85ef1