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