yaffs_fs.c

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