X-Git-Url: http://www.aleph1.co.uk/gitweb/?p=yaffs2.git;a=blobdiff_plain;f=yaffs_vfs_single.c;h=d77c87dabfd85b3dafa9b9eb9fd9fc5975a5f344;hp=32734a68ee21dfeefda42cd86d5056d7fc8cc848;hb=6076b3bffffb8c1b26b41674cd9e6c5b7eeb1293;hpb=6500cebaa2c93512d544719956af259ca13f83b7 diff --git a/yaffs_vfs_single.c b/yaffs_vfs_single.c index 32734a6..d77c87d 100644 --- a/yaffs_vfs_single.c +++ b/yaffs_vfs_single.c @@ -1,7 +1,7 @@ /* * YAFFS: Yet Another Flash File System. A NAND-flash specific file system. * - * Copyright (C) 2002-2010 Aleph One Ltd. + * Copyright (C) 2002-2011 Aleph One Ltd. * for Toby Churchill Ltd and Brightstar Engineering * * Created by Charles Manning @@ -42,7 +42,6 @@ #include #include #include -#include #include #include #include @@ -72,6 +71,7 @@ unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS; unsigned int yaffs_auto_checkpoint = 1; unsigned int yaffs_gc_control = 1; unsigned int yaffs_bg_enable = 1; +unsigned int yaffs_auto_select = 1; /* Module Parameters */ module_param(yaffs_trace_mask, uint, 0644); @@ -79,6 +79,7 @@ module_param(yaffs_wr_attempts, uint, 0644); module_param(yaffs_auto_checkpoint, uint, 0644); module_param(yaffs_gc_control, uint, 0644); module_param(yaffs_bg_enable, uint, 0644); +module_param(yaffs_auto_select, uint, 0644); #define yaffs_devname(sb, buf) bdevname(sb->s_bdev, buf) @@ -193,7 +194,7 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, struct yaffs_obj *obj = NULL; struct yaffs_dev *dev; struct yaffs_obj *parent = yaffs_inode_to_obj(dir); - int error = -ENOSPC; + int error; uid_t uid = current->cred->fsuid; gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->cred->fsgid; @@ -219,6 +220,11 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, yaffs_gross_lock(dev); + if (yaffs_get_n_free_chunks(dev) < 1) { + error = -ENOSPC; + goto err_out; + } + switch (mode & S_IFMT) { default: /* Special (socket, fifo, device...) */ @@ -243,13 +249,14 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, break; } + if (!obj) { + error = -ENOMEM; + goto err_out; + } + /* Can not call yaffs_get_inode() with gross lock held */ yaffs_gross_unlock(dev); - if (!obj) { - yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod failed making object"); - return -ENOMEM; - } inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj); d_instantiate(dentry, inode); @@ -258,8 +265,13 @@ static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode, "yaffs_mknod created object %d count = %d", obj->obj_id, atomic_read(&inode->i_count)); yaffs_fill_inode_from_obj(dir, parent); - return 0; + +err_out: + yaffs_gross_unlock(dev); + yaffs_trace(YAFFS_TRACE_OS, "yaffs_mknod error %d", error); + return error; + } static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode) @@ -294,7 +306,7 @@ static int yaffs_link(struct dentry *old_dentry, struct inode *dir, obj); if (link) { - old_dentry->d_inode->i_nlink = yaffs_get_obj_link_count(obj); + set_nlink(old_dentry->d_inode, yaffs_get_obj_link_count(obj)); d_instantiate(dentry, old_dentry->d_inode); atomic_inc(&old_dentry->d_inode->i_count); yaffs_trace(YAFFS_TRACE_OS, @@ -325,6 +337,14 @@ static int yaffs_symlink(struct inode *dir, struct dentry *dentry, yaffs_trace(YAFFS_TRACE_OS, "yaffs_symlink"); + if (strnlen(dentry->d_name.name, YAFFS_MAX_NAME_LENGTH + 1) > + YAFFS_MAX_NAME_LENGTH) + return -ENAMETOOLONG; + + if (strnlen(symname, YAFFS_MAX_ALIAS_LENGTH + 1) > + YAFFS_MAX_ALIAS_LENGTH) + return -ENAMETOOLONG; + dev = yaffs_inode_to_obj(dir)->my_dev; yaffs_gross_lock(dev); obj = yaffs_create_symlink(yaffs_inode_to_obj(dir), dentry->d_name.name, @@ -406,10 +426,9 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) ret_val = yaffs_unlinker(obj, dentry->d_name.name); if (ret_val == YAFFS_OK) { - dentry->d_inode->i_nlink--; + inode_dec_link_count(dentry->d_inode); dir->i_version++; yaffs_gross_unlock(dev); - mark_inode_dirty(dentry->d_inode); update_dir_time(dir); return 0; } @@ -417,7 +436,8 @@ static int yaffs_unlink(struct inode *dir, struct dentry *dentry) return -ENOTEMPTY; } -static int yaffs_sync_object(struct file *file, int datasync) +static int yaffs_sync_object(struct file *file, + loff_t start, loff_t end, int datasync) { struct yaffs_obj *obj; @@ -430,7 +450,7 @@ static int yaffs_sync_object(struct file *file, int datasync) yaffs_trace(YAFFS_TRACE_OS | YAFFS_TRACE_SYNC, "yaffs_sync_object"); yaffs_gross_lock(dev); - yaffs_flush_file(obj, 1, datasync); + yaffs_flush_file(obj, 1, datasync, 0); yaffs_gross_unlock(dev); return 0; } @@ -473,10 +493,8 @@ static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry, yaffs_gross_unlock(dev); if (ret_val == YAFFS_OK) { - if (target) { - new_dentry->d_inode->i_nlink--; - mark_inode_dirty(new_dentry->d_inode); - } + if (target) + inode_dec_link_count(new_dentry->d_inode); update_dir_time(old_dir); if (old_dir != new_dir) @@ -531,7 +549,6 @@ static int yaffs_setattr(struct dentry *dentry, struct iattr *attr) return error; } -#ifdef CONFIG_YAFFS_XATTR static int yaffs_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags) { @@ -616,8 +633,6 @@ static ssize_t yaffs_listxattr(struct dentry *dentry, char *buff, size_t size) return error; } -#endif - static const struct inode_operations yaffs_dir_inode_operations = { .create = yaffs_create, .lookup = yaffs_lookup, @@ -629,12 +644,10 @@ static const struct inode_operations yaffs_dir_inode_operations = { .mknod = yaffs_mknod, .rename = yaffs_rename, .setattr = yaffs_setattr, -#ifdef CONFIG_YAFFS_XATTR .setxattr = yaffs_setxattr, .getxattr = yaffs_getxattr, .listxattr = yaffs_listxattr, .removexattr = yaffs_removexattr, -#endif }; /*-----------------------------------------------------------------*/ /* Directory search context allows us to unlock access to yaffs during @@ -877,7 +890,7 @@ static int yaffs_file_flush(struct file *file, fl_owner_t id) yaffs_gross_lock(dev); - yaffs_flush_file(obj, 1, 0); + yaffs_flush_file(obj, 1, 0, 0); yaffs_gross_unlock(dev); @@ -1085,12 +1098,14 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) unsigned char *pg_buf; int ret; struct yaffs_dev *dev; + loff_t pos = ((loff_t) pg->index) << PAGE_CACHE_SHIFT; yaffs_trace(YAFFS_TRACE_OS, - "yaffs_readpage_nolock at %08x, size %08x", - (unsigned)(pg->index << PAGE_CACHE_SHIFT), + "yaffs_readpage_nolock at %lld, size %08x", + (long long)pos, (unsigned)PAGE_CACHE_SIZE); + obj = yaffs_dentry_to_obj(f->f_dentry); dev = obj->my_dev; @@ -1102,8 +1117,7 @@ static int yaffs_readpage_nolock(struct file *f, struct page *pg) yaffs_gross_lock(dev); - ret = yaffs_file_rd(obj, pg_buf, - pg->index << PAGE_CACHE_SHIFT, PAGE_CACHE_SIZE); + ret = yaffs_file_rd(obj, pg_buf, pos, PAGE_CACHE_SIZE); yaffs_gross_unlock(dev); @@ -1206,7 +1220,8 @@ static int yaffs_writepage(struct page *page, struct writeback_control *wbc) (int)obj->variant.file_variant.file_size, (int)inode->i_size); n_written = yaffs_wr_file(obj, buffer, - page->index << PAGE_CACHE_SHIFT, n_bytes, 0); + ((loff_t)page->index) << PAGE_CACHE_SHIFT, + n_bytes, 0); yaffs_touch_super(dev); @@ -1481,7 +1496,7 @@ static void yaffs_flush_inodes(struct super_block *sb) if (obj) { yaffs_trace(YAFFS_TRACE_OS, "flushing obj %d", obj->obj_id); - yaffs_flush_file(obj, 1, 0); + yaffs_flush_file(obj, 1, 0, 0); } } } @@ -1495,7 +1510,7 @@ static void yaffs_flush_super(struct super_block *sb, int do_checkpoint) yaffs_flush_inodes(sb); yaffs_update_dirty_dirs(dev); - yaffs_flush_whole_cache(dev); + yaffs_flush_whole_cache(dev, 1); if (do_checkpoint) yaffs_checkpoint_save(dev); } @@ -1790,12 +1805,10 @@ static const struct address_space_operations yaffs_file_address_operations = { static const struct inode_operations yaffs_file_inode_operations = { .setattr = yaffs_setattr, -#ifdef CONFIG_YAFFS_XATTR .setxattr = yaffs_setxattr, .getxattr = yaffs_getxattr, .listxattr = yaffs_listxattr, .removexattr = yaffs_removexattr, -#endif }; static const struct inode_operations yaffs_symlink_inode_operations = { @@ -1803,17 +1816,17 @@ static const struct inode_operations yaffs_symlink_inode_operations = { .follow_link = yaffs_follow_link, .put_link = yaffs_put_link, .setattr = yaffs_setattr, -#ifdef CONFIG_YAFFS_XATTR .setxattr = yaffs_setxattr, .getxattr = yaffs_getxattr, .listxattr = yaffs_listxattr, .removexattr = yaffs_removexattr, -#endif }; static void yaffs_fill_inode_from_obj(struct inode *inode, struct yaffs_obj *obj) { + u32 mode; + if (!inode || !obj) { yaffs_trace(YAFFS_TRACE_OS, "yaffs_fill_inode invalid parameters"); @@ -1822,7 +1835,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, /* Check mode against the variant type * and attempt to repair if broken. */ - u32 mode = obj->yst_mode; + mode = obj->yst_mode; switch (obj->variant_type) { case YAFFS_OBJECT_TYPE_FILE: @@ -1867,7 +1880,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, inode->i_ctime.tv_nsec = 0; inode->i_size = yaffs_get_obj_length(obj); inode->i_blocks = (inode->i_size + 511) >> 9; - inode->i_nlink = yaffs_get_obj_link_count(obj); + set_nlink(inode, yaffs_get_obj_link_count(obj)); yaffs_trace(YAFFS_TRACE_OS, "yaffs_fill_inode mode %x uid %d gid %d size %d count %d", inode->i_mode, inode->i_uid, inode->i_gid, @@ -1899,6 +1912,7 @@ static void yaffs_fill_inode_from_obj(struct inode *inode, static void yaffs_put_super(struct super_block *sb) { struct yaffs_dev *dev = yaffs_super_to_dev(sb); + struct mtd_info *mtd = yaffs_dev_to_mtd(dev); yaffs_trace(YAFFS_TRACE_OS, "yaffs_put_super"); @@ -1928,24 +1942,62 @@ static void yaffs_put_super(struct super_block *sb) } kfree(dev); + + if (mtd && mtd->sync) + mtd->sync(mtd); + + if (mtd) + put_mtd_device(mtd); } -static void yaffs_mtd_put_super(struct super_block *sb) +/* the function only is used to change dev->read_only when this file system + * is remounted. + */ +static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data) { - struct mtd_info *mtd = yaffs_dev_to_mtd(yaffs_super_to_dev(sb)); + int read_only = 0; + struct mtd_info *mtd; + struct yaffs_dev *dev = 0; - if (mtd->sync) - mtd->sync(mtd); + /* Get the device */ + mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); + if (!mtd) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "MTD device #%u doesn't appear to exist", + MINOR(sb->s_dev)); + return 1; + } + + /* Check it's NAND */ + if (mtd->type != MTD_NANDFLASH) { + yaffs_trace(YAFFS_TRACE_ALWAYS, + "MTD device is not NAND it's type %d", + mtd->type); + return 1; + } + + read_only = ((*flags & MS_RDONLY) != 0); + if (!read_only && !(mtd->flags & MTD_WRITEABLE)) { + read_only = 1; + printk(KERN_INFO + "yaffs: mtd is read only, setting superblock read only"); + *flags |= MS_RDONLY; + } + + dev = sb->s_fs_info; + dev->read_only = read_only; - put_mtd_device(mtd); + return 0; } + static const struct super_operations yaffs_super_ops = { .statfs = yaffs_statfs, .put_super = yaffs_put_super, .evict_inode = yaffs_evict_inode, .sync_fs = yaffs_sync_fs, .write_super = yaffs_write_super, + .remount_fs = yaffs_remount_fs, }; static struct super_block *yaffs_internal_read_super(int yaffs_version, @@ -2021,7 +2073,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, /* Get the device */ mtd = get_mtd_device(NULL, MINOR(sb->s_dev)); - if (!mtd) { + if (IS_ERR(mtd)) { yaffs_trace(YAFFS_TRACE_ALWAYS, "MTD device #%u doesn't appear to exist", MINOR(sb->s_dev)); @@ -2047,20 +2099,16 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, yaffs_trace(YAFFS_TRACE_OS, " erasesize %d", mtd->erasesize); yaffs_trace(YAFFS_TRACE_OS, " size %lld", mtd->size); -#ifdef CONFIG_YAFFS_AUTO_YAFFS2 - - if (yaffs_version == 1 && mtd->writesize >= 2048) { + if (yaffs_auto_select && yaffs_version == 1 && mtd->writesize >= 2048) { yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs2"); yaffs_version = 2; } - /* Added NCB 26/5/2006 for completeness */ - if (yaffs_version == 2 && !options.inband_tags && + if (yaffs_auto_select && yaffs_version == 2 && !options.inband_tags && mtd->writesize == 512) { yaffs_trace(YAFFS_TRACE_ALWAYS, "auto selecting yaffs1"); yaffs_version = 1; } -#endif if (yaffs_version == 2) { /* Check for version 2 style functions */ @@ -2119,9 +2167,7 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, kfree(context); dev = NULL; context = NULL; - } - if (!dev) { /* Deep shit could not allocate device structure */ yaffs_trace(YAFFS_TRACE_ALWAYS, "yaffs_read_super failed trying to allocate yaffs_dev"); @@ -2157,40 +2203,19 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, param->n_caches = (options.no_cache) ? 0 : 10; param->inband_tags = options.inband_tags; -#ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD param->disable_lazy_load = 1; -#endif -#ifdef CONFIG_YAFFS_XATTR param->enable_xattr = 1; -#endif if (options.lazy_loading_overridden) param->disable_lazy_load = !options.lazy_loading_enabled; -#ifdef CONFIG_YAFFS_DISABLE_TAGS_ECC - param->no_tags_ecc = 1; -#endif - -#ifdef CONFIG_YAFFS_DISABLE_BACKGROUND -#else param->defered_dir_update = 1; -#endif if (options.tags_ecc_overridden) param->no_tags_ecc = !options.tags_ecc_on; -#ifdef CONFIG_YAFFS_EMPTY_LOST_AND_FOUND param->empty_lost_n_found = 1; -#endif -#ifdef CONFIG_YAFFS_DISABLE_BLOCK_REFRESHING - param->refresh_period = 0; -#else param->refresh_period = 500; -#endif - -#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED - param->always_check_erased = 1; -#endif if (options.empty_lost_and_found_overridden) param->empty_lost_n_found = options.empty_lost_and_found; @@ -2225,13 +2250,11 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, yaffs_dev_to_lc(dev)->put_super_fn = yaffs_mtd_put_super; param->sb_dirty_fn = yaffs_touch_super; - param->gc_control = yaffs_gc_control_callback; + param->gc_control_fn = yaffs_gc_control_callback; yaffs_dev_to_lc(dev)->super = sb; -#ifndef CONFIG_YAFFS_DOES_ECC param->use_nand_ecc = 1; -#endif param->skip_checkpt_rd = options.skip_checkpoint_read; param->skip_checkpt_wr = options.skip_checkpoint_write; @@ -2274,6 +2297,8 @@ static struct super_block *yaffs_internal_read_super(int yaffs_version, if (!context->bg_thread) param->defered_dir_update = 0; + sb->s_maxbytes = yaffs_max_file_size(dev); + /* Release lock before yaffs_get_inode() */ yaffs_gross_unlock(dev); @@ -2313,47 +2338,43 @@ static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data, return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL; } -static int yaffs_read_super(struct file_system_type *fs, +static struct dentry *yaffs_mount(struct file_system_type *fs, int flags, const char *dev_name, - void *data, struct vfsmount *mnt) + void *data) { - - return get_sb_bdev(fs, flags, dev_name, data, - yaffs_internal_read_super_mtd, mnt); + return mount_bdev(fs, flags, dev_name, data, + yaffs_internal_read_super_mtd); } static struct file_system_type yaffs_fs_type = { .owner = THIS_MODULE, .name = "yaffs", - .get_sb = yaffs_read_super, + .mount = yaffs_mount, .kill_sb = kill_block_super, .fs_flags = FS_REQUIRES_DEV, }; -#ifdef CONFIG_YAFFS_YAFFS2 - static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data, int silent) { return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL; } -static int yaffs2_read_super(struct file_system_type *fs, - int flags, const char *dev_name, void *data, - struct vfsmount *mnt) +static struct dentry *yaffs2_mount(struct file_system_type *fs, + int flags, const char *dev_name, void *data) { - return get_sb_bdev(fs, flags, dev_name, data, - yaffs2_internal_read_super_mtd, mnt); + return mount_bdev(fs, flags, dev_name, data, + yaffs2_internal_read_super_mtd); } static struct file_system_type yaffs2_fs_type = { .owner = THIS_MODULE, .name = "yaffs2", - .get_sb = yaffs2_read_super, + .mount = yaffs2_mount, .kill_sb = kill_block_super, .fs_flags = FS_REQUIRES_DEV, }; -#endif /* CONFIG_YAFFS_YAFFS2 */ + static struct proc_dir_entry *my_proc_entry; @@ -2387,9 +2408,10 @@ static char *yaffs_dump_dev_part0(char *buf, struct yaffs_dev *dev) static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev) { - buf += - sprintf(buf, "data_bytes_per_chunk.. %d\n", - dev->data_bytes_per_chunk); + buf += sprintf(buf, "max file size......... %lld\n", + (long long) yaffs_max_file_size(dev)); + buf += sprintf(buf, "data_bytes_per_chunk.. %d\n", + dev->data_bytes_per_chunk); buf += sprintf(buf, "chunk_grp_bits........ %d\n", dev->chunk_grp_bits); buf += sprintf(buf, "chunk_grp_size........ %d\n", dev->chunk_grp_size); buf += @@ -2414,7 +2436,7 @@ static char *yaffs_dump_dev_part1(char *buf, struct yaffs_dev *dev) buf += sprintf(buf, "n_gc_blocks........... %u\n", dev->n_gc_blocks); buf += sprintf(buf, "bg_gcs................ %u\n", dev->bg_gcs); buf += - sprintf(buf, "n_retired_writes...... %u\n", dev->n_retired_writes); + sprintf(buf, "n_retried_writes...... %u\n", dev->n_retried_writes); buf += sprintf(buf, "n_retired_blocks...... %u\n", dev->n_retired_blocks); buf += sprintf(buf, "n_ecc_fixed........... %u\n", dev->n_ecc_fixed); @@ -2492,149 +2514,6 @@ static int yaffs_proc_read(char *page, } -/** - * Set the verbosity of the warnings and error messages. - * - * Note that the names can only be a..z or _ with the current code. - */ - -static struct { - char *mask_name; - unsigned mask_bitfield; -} mask_flags[] = { - {"allocate", YAFFS_TRACE_ALLOCATE}, - {"always", YAFFS_TRACE_ALWAYS}, - {"background", YAFFS_TRACE_BACKGROUND}, - {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS}, - {"buffers", YAFFS_TRACE_BUFFERS}, - {"bug", YAFFS_TRACE_BUG}, - {"checkpt", YAFFS_TRACE_CHECKPOINT}, - {"deletion", YAFFS_TRACE_DELETION}, - {"erase", YAFFS_TRACE_ERASE}, - {"error", YAFFS_TRACE_ERROR}, - {"gc_detail", YAFFS_TRACE_GC_DETAIL}, - {"gc", YAFFS_TRACE_GC}, - {"lock", YAFFS_TRACE_LOCK}, - {"mtd", YAFFS_TRACE_MTD}, - {"nandaccess", YAFFS_TRACE_NANDACCESS}, - {"os", YAFFS_TRACE_OS}, - {"scan_debug", YAFFS_TRACE_SCAN_DEBUG}, - {"scan", YAFFS_TRACE_SCAN}, - {"mount", YAFFS_TRACE_MOUNT}, - {"tracing", YAFFS_TRACE_TRACING}, - {"sync", YAFFS_TRACE_SYNC}, - {"write", YAFFS_TRACE_WRITE}, - {"verify", YAFFS_TRACE_VERIFY}, - {"verify_nand", YAFFS_TRACE_VERIFY_NAND}, - {"verify_full", YAFFS_TRACE_VERIFY_FULL}, - {"verify_all", YAFFS_TRACE_VERIFY_ALL}, - {"all", 0xffffffff}, - {"none", 0}, - {NULL, 0}, -}; - -#define MAX_MASK_NAME_LENGTH 40 -static int yaffs_proc_write_trace_options(struct file *file, const char *buf, - unsigned long count, void *data) -{ - unsigned rg = 0, mask_bitfield; - char *end; - char *mask_name; - const char *x; - char substring[MAX_MASK_NAME_LENGTH + 1]; - int i; - int done = 0; - int add, len = 0; - int pos = 0; - - rg = yaffs_trace_mask; - - while (!done && (pos < count)) { - done = 1; - while ((pos < count) && isspace(buf[pos])) - pos++; - - switch (buf[pos]) { - case '+': - case '-': - case '=': - add = buf[pos]; - pos++; - break; - - default: - add = ' '; - break; - } - mask_name = NULL; - - mask_bitfield = simple_strtoul(buf + pos, &end, 0); - - if (end > buf + pos) { - mask_name = "numeral"; - len = end - (buf + pos); - pos += len; - done = 0; - } else { - for (x = buf + pos, i = 0; - (*x == '_' || (*x >= 'a' && *x <= 'z')) && - i < MAX_MASK_NAME_LENGTH; x++, i++, pos++) - substring[i] = *x; - substring[i] = '\0'; - - for (i = 0; mask_flags[i].mask_name != NULL; i++) { - if (strcmp(substring, mask_flags[i].mask_name) - == 0) { - mask_name = mask_flags[i].mask_name; - mask_bitfield = - mask_flags[i].mask_bitfield; - done = 0; - break; - } - } - } - - if (mask_name != NULL) { - done = 0; - switch (add) { - case '-': - rg &= ~mask_bitfield; - break; - case '+': - rg |= mask_bitfield; - break; - case '=': - rg = mask_bitfield; - break; - default: - rg |= mask_bitfield; - break; - } - } - } - - yaffs_trace_mask = rg | YAFFS_TRACE_ALWAYS; - - printk(KERN_DEBUG "new trace = 0x%08X\n", yaffs_trace_mask); - - if (rg & YAFFS_TRACE_ALWAYS) { - for (i = 0; mask_flags[i].mask_name != NULL; i++) { - char flag; - flag = ((rg & mask_flags[i].mask_bitfield) == - mask_flags[i].mask_bitfield) ? '+' : '-'; - printk(KERN_DEBUG "%c%s\n", flag, - mask_flags[i].mask_name); - } - } - - return count; -} - -static int yaffs_proc_write(struct file *file, const char *buf, - unsigned long count, void *data) -{ - return yaffs_proc_write_trace_options(file, buf, count, data); -} /* Stuff to handle installation of file systems */ struct file_system_to_install { @@ -2656,11 +2535,6 @@ static int __init init_yaffs_fs(void) yaffs_trace(YAFFS_TRACE_ALWAYS, "yaffs built " __DATE__ " " __TIME__ " Installing."); -#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED - yaffs_trace(YAFFS_TRACE_ALWAYS, - "\n\nYAFFS-WARNING CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED selected.\n\n\n"); -#endif - mutex_init(&yaffs_context_lock); /* Install the proc_fs entries */ @@ -2668,7 +2542,7 @@ static int __init init_yaffs_fs(void) S_IRUGO | S_IFREG, NULL); if (my_proc_entry) { - my_proc_entry->write_proc = yaffs_proc_write; + my_proc_entry->write_proc = NULL; my_proc_entry->read_proc = yaffs_proc_read; my_proc_entry->data = NULL; } else { @@ -2728,5 +2602,5 @@ module_init(init_yaffs_fs) module_exit(exit_yaffs_fs) MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system"); -MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2010"); +MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2011"); MODULE_LICENSE("GPL");