cp -u autoconf.h sim/include/generated/autoconf.h

.patch.ts: kernel345.patch

	CWD=`pwd` && cd $(KERNEL_DIR) && patch -p1 < $$CWD/kernel345.patch && cd $$CWD && touch .patch.ts

unpatch: 

	CWD=`pwd` && cd $(KERNEL_DIR) && git reset --hard $(KERNEL_VERSION) && cd $$CWD && rm -f .patch.ts

diff --git a/include/linux/slab.h b/include/linux/slab.h

index a595dce..4a4dea3 100644

--- a/include/linux/slab.h

+++ b/include/linux/slab.h

@@ -185,6 +185,8 @@ size_t ksize(const void *);

 #include <linux/slub_def.h>

 #elif defined(CONFIG_SLOB)

 #include <linux/slob_def.h>

+#elif defined(CONFIG_SIM)

+#include <asm/slab.h>

 #else

 #include <linux/slab_def.h>

 #endif

#include <asm/atomic.h>

#include "sim-assert.h"

long atomic64_read(const atomic64_t *v)

{

	return &(v)->counter;

}

long atomic64_add_return(long i, atomic64_t *v)

 {

	v->counter += i;

    return v->counter;

 }

void atomic64_sub(long i, atomic64_t *v)

{

	v->counter -= i;

}

#include <linux/fs.h>

#include <linux/dcache.h>

#include <linux/slab.h>

#include "sim-assert.h"

static struct kmem_cache *dentry_cache __read_mostly;

struct kmem_cache *names_cachep __read_mostly;

/**

 * __d_alloc	-	allocate a dcache entry

 * @sb: filesystem it will belong to

 * @name: qstr of the name

 *

 * Allocates a dentry. It returns %NULL if there is insufficient memory

 * available. On a success the dentry is returned. The name passed in is

 * copied and the copy passed in may be reused after this call.

 */

struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)

{

	struct dentry *dentry;

	char *dname;

	dentry =	dentry =  kmalloc(sizeof (struct dentry), GFP_KERNEL); //  kmem_cache_alloc(dentry_cache, GFP_KERNEL);

	if (!dentry)

		return NULL;

	if (name->len > DNAME_INLINE_LEN-1) {

		dname = kmalloc(name->len + 1, GFP_KERNEL);

		if (!dname) {

			kmem_cache_free(dentry_cache, dentry);

			return NULL;

		}

	} else  {

		dname = dentry->d_iname;

	}

	dentry->d_name.name = dname;

	dentry->d_name.len = name->len;

	dentry->d_name.hash = name->hash;

	memcpy(dname, name->name, name->len);

	dname[name->len] = 0;

	dentry->d_count = 1;

	dentry->d_flags = 0;

	spin_lock_init(&dentry->d_lock);

	seqcount_init(&dentry->d_seq);

	dentry->d_inode = NULL;

	dentry->d_parent = dentry;

	dentry->d_sb = sb;

	dentry->d_op = NULL;

	dentry->d_fsdata = NULL;

	INIT_HLIST_BL_NODE(&dentry->d_hash);

	INIT_LIST_HEAD(&dentry->d_lru);

	INIT_LIST_HEAD(&dentry->d_subdirs);

	INIT_LIST_HEAD(&dentry->d_alias);

	INIT_LIST_HEAD(&dentry->d_u.d_child);

	d_set_d_op(dentry, dentry->d_sb->s_d_op);

//	this_cpu_inc(nr_dentry);

	return dentry;

}

void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op)

{

	WARN_ON_ONCE(dentry->d_op);

	WARN_ON_ONCE(dentry->d_flags & (DCACHE_OP_HASH	|

				DCACHE_OP_COMPARE	|

				DCACHE_OP_REVALIDATE	|

				DCACHE_OP_DELETE ));

	dentry->d_op = op;

	if (!op)

		return;

	if (op->d_hash)

		dentry->d_flags |= DCACHE_OP_HASH;

	if (op->d_compare)

		dentry->d_flags |= DCACHE_OP_COMPARE;

	if (op->d_revalidate)

		dentry->d_flags |= DCACHE_OP_REVALIDATE;

	if (op->d_delete)

		dentry->d_flags |= DCACHE_OP_DELETE;

	if (op->d_prune)

		dentry->d_flags |= DCACHE_OP_PRUNE;

}

#include "sim.h"

#include "sim-assert.h"

#include <linux/fs.h>

ssize_t generic_file_aio_read(struct kiocb *a, const struct iovec *b, unsigned long c, loff_t d)

{

	sim_assert (false);

	return 0;

}

int generic_file_readonly_mmap(struct file * file, struct vm_area_struct * vma)

{

	return -ENOSYS;

}

#include <linux/sysctl.h>

#include <fs/mount.h>

#include <linux/slab.h>

#include <linux/backing-dev.h>

#include <linux/pagemap.h>

#include <linux/user_namespace.h>

int proc_nr_inodes(ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos)

{

	  sim_assert (false);

	  return 0;

}

int proc_nr_dentry(ctl_table *table, int write, void __user *buffer,

		   size_t *lenp, loff_t *ppos)

{

	sim_assert (false);

		  return 0;

}

/*

 * Handle writeback of dirty data for the device backed by this bdi. Also

 * wakes up periodically and does kupdated style flushing.

 */

int bdi_writeback_thread(void *data)

{

	sim_assert (false);

	return 0;

}

void get_filesystem(struct file_system_type *fs)

{

	return;

}

//#include <fs/proc/proc_sysctl.c>

unsigned int nr_free_buffer_pages(void)

{

	return 1024;

}

static unsigned long local_irqflags = 0;

#include <asm-generic/barrier.h>

#define CONFIG_SIM 1

#define CONFIG_EXPERIMENTAL 1

#define CONFIG_KTIME_SCALAR 1

#define CONFIG_MODULES 1

#define CONFIG_GENERIC_CSUM 1

#define CONFIG_PRINTK 1

#define CONFIG_RWSEM_GENERIC_SPINLOCK 1

#define CONFIG_GENERIC_FIND_NEXT_BIT 1

#define CONFIG_GENERIC_HWEIGHT 1

#define CONFIG_TRACE_IRQFLAGS_SUPPORT 1

#define CONFIG_NO_HZ 1

#define CONFIG_HZ 250

#define CONFIG_TINY_RCU 1

#define CONFIG_HZ_250 1

#define CONFIG_BASE_SMALL 1

#define CONFIG_SPLIT_PTLOCK_CPUS 1

#define CONFIG_FLATMEM 1

#define CONFIG_SYSCTL 1

#define CONFIG_PROC_FS 1

#define CONFIG_SYSFS 1

#define CONFIG_PROC_SYSCTL 1

#define CONFIG_NET 1

#define CONFIG_PACKET 1

#define CONFIG_UNIX 1

#define CONFIG_XFRM 1

#define CONFIG_XFRM_USER 1

#define CONFIG_XFRM_SUB_POLICY 1

#define CONFIG_XFRM_MIGRATE 1

#define CONFIG_XFRM_STATISTICS 1

#define CONFIG_XFRM_IPCOMP_MODULE 1

#define CONFIG_NET_KEY 1

#define CONFIG_NET_KEY_MIGRATE 1

#define CONFIG_INET 1

#define CONFIG_IP_MULTICAST 1

#define CONFIG_IP_ADVANCED_ROUTER 1

#define CONFIG_IP_MULTIPLE_TABLES 1

#define CONFIG_IP_ROUTE_MULTIPATH 1

#define CONFIG_IP_ROUTE_VERBOSE 1

#define CONFIG_NET_IPIP_MODULE 1

#define CONFIG_IP_MROUTE 1

#define CONFIG_IP_MROUTE_MULTIPLE_TABLES 1

#define CONFIG_IP_PIMSM_V1 1

#define CONFIG_IP_PIMSM_V2 1

#define CONFIG_ARPD 1

#define CONFIG_SYN_COOKIES 1

#define CONFIG_INET_AH_MODULE 1

#define CONFIG_INET_ESP_MODULE 1

#define CONFIG_INET_IPCOMP_MODULE 1

#define CONFIG_INET_XFRM_TUNNEL_MODULE 1

#define CONFIG_INET_TUNNEL 1

#define CONFIG_INET_XFRM_MODE_TRANSPORT 1

#define CONFIG_INET_XFRM_MODE_TUNNEL 1

#define CONFIG_INET_XFRM_MODE_BEET 1

#define CONFIG_INET_DIAG_MODULE 1

#define CONFIG_INET_TCP_DIAG_MODULE 1

#define CONFIG_TCP_CONG_ADVANCED 1

#define CONFIG_TCP_CONG_BIC_MODULE 1

#define CONFIG_TCP_CONG_CUBIC_MODULE 1

#define CONFIG_TCP_CONG_WESTWOOD_MODULE 1

#define CONFIG_TCP_CONG_HTCP_MODULE 1

#define CONFIG_DEFAULT_RENO 1

#define CONFIG_DEFAULT_TCP_CONG "reno"

#define CONFIG_IPV6 1

#define CONFIG_IPV6_PRIVACY 1

#define CONFIG_IPV6_ROUTER_PREF 1

#define CONFIG_INET6_AH_MODULE 1

#define CONFIG_INET6_ESP_MODULE 1

#define CONFIG_INET6_IPCOMP_MODULE 1

#define CONFIG_IPV6_MIP6 1

#define CONFIG_INET6_XFRM_TUNNEL_MODULE 1

#define CONFIG_INET6_TUNNEL 1

#define CONFIG_INET6_XFRM_MODE_TRANSPORT 1

#define CONFIG_INET6_XFRM_MODE_TUNNEL 1

#define CONFIG_INET6_XFRM_MODE_BEET 1

#define CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION 1

#define CONFIG_IPV6_SIT 1

#define CONFIG_IPV6_NDISC_NODETYPE 1

#define CONFIG_IPV6_TUNNEL 1

#define CONFIG_IPV6_MULTIPLE_TABLES 1

#define CONFIG_IPV6_SUBTREES 1

#define CONFIG_ATM_MODULE 1

#define CONFIG_ATM_CLIP_MODULE 1

#define CONFIG_ATM_CLIP_NO_ICMP 1

#define CONFIG_ATM_LANE_MODULE 1

#define CONFIG_ATM_MPOA_MODULE 1

#define CONFIG_ATM_BR2684_MODULE 1

#define CONFIG_ATM_BR2684_IPFILTER 1

#define CONFIG_L2TP_MODULE 1

#define CONFIG_STP_MODULE 1

#define CONFIG_GARP_MODULE 1

#define CONFIG_BRIDGE_MODULE 1

#define CONFIG_BRIDGE_IGMP_SNOOPING 1

#define CONFIG_VLAN_8021Q_MODULE 1

#define CONFIG_VLAN_8021Q_GVRP 1

#define CONFIG_DECNET_MODULE 1

#define CONFIG_LLC_MODULE 1

#define CONFIG_LLC2_MODULE 1

#define CONFIG_IPX_MODULE 1

#define CONFIG_IPX_INTERN 1

#define CONFIG_ATALK_MODULE 1

#define CONFIG_DEV_APPLETALK_MODULE 1

#define CONFIG_IPDDP_MODULE 1

#define CONFIG_IPDDP_ENCAP 1

#define CONFIG_IPDDP_DECAP 1

#define CONFIG_PHONET_MODULE 1

#define CONFIG_BQL 1

#define CONFIG_NET_PKTGEN_MODULE 1

#define CONFIG_CAN_MODULE 1

#define CONFIG_CAN_RAW_MODULE 1

#define CONFIG_CAN_BCM_MODULE 1

#define CONFIG_CAN_VCAN_MODULE 1

#define CONFIG_CAN_DEV_MODULE 1

#define CONFIG_CAN_CALC_BITTIMING 1

#define CONFIG_CAN_SJA1000_MODULE 1

#define CONFIG_CAN_SJA1000_PLATFORM_MODULE 1

#define CONFIG_CAN_DEBUG_DEVICES 1

#define CONFIG_IRDA_MODULE 1

#define CONFIG_IRLAN_MODULE 1

#define CONFIG_IRCOMM_MODULE 1

#define CONFIG_IRDA_ULTRA 1

#define CONFIG_IRDA_CACHE_LAST_LSAP 1

#define CONFIG_IRDA_FAST_RR 1

#define CONFIG_IRDA_DEBUG 1

#define CONFIG_IRTTY_SIR_MODULE 1

#define CONFIG_DONGLE 1

#define CONFIG_ESI_DONGLE_MODULE 1

#define CONFIG_ACTISYS_DONGLE_MODULE 1

#define CONFIG_TEKRAM_DONGLE_MODULE 1

#define CONFIG_TOIM3232_DONGLE_MODULE 1

#define CONFIG_LITELINK_DONGLE_MODULE 1

#define CONFIG_BT_MODULE 1

#define CONFIG_BT_RFCOMM_MODULE 1

#define CONFIG_BT_RFCOMM_TTY 1

#define CONFIG_BT_BNEP_MODULE 1

#define CONFIG_BT_BNEP_MC_FILTER 1

#define CONFIG_BT_BNEP_PROTO_FILTER 1

#define CONFIG_BT_HCIUART_MODULE 1

#define CONFIG_BT_HCIUART_H4 1

#define CONFIG_BT_HCIUART_BCSP 1

#define CONFIG_BT_HCIUART_LL 1

#define CONFIG_BT_HCIVHCI_MODULE 1

#define CONFIG_BT_MRVL_MODULE 1

#define CONFIG_FIB_RULES 1

#define CONFIG_WIMAX_MODULE 1

#define CONFIG_WIMAX_DEBUG_LEVEL 8

#define CONFIG_RFKILL_MODULE 1

#define CONFIG_CAIF_MODULE 1

#define CONFIG_CAIF_DEBUG 1

#define CONFIG_CAIF_NETDEV_MODULE 1

#define CONFIG_STANDALONE 1

#define CONFIG_PREVENT_FIRMWARE_BUILD 1

#define CONFIG_FW_LOADER 1

#define CONFIG_FIRMWARE_IN_KERNEL 1

#define CONFIG_EXTRA_FIRMWARE ""

#define CONFIG_CRYPTO 1

#define CONFIG_CRYPTO_ALGAPI_MODULE 1

#define CONFIG_CRYPTO_ALGAPI2_MODULE 1

#define CONFIG_CRYPTO_AEAD_MODULE 1

#define CONFIG_CRYPTO_AEAD2_MODULE 1

#define CONFIG_CRYPTO_BLKCIPHER_MODULE 1

#define CONFIG_CRYPTO_BLKCIPHER2_MODULE 1

#define CONFIG_CRYPTO_HASH_MODULE 1

#define CONFIG_CRYPTO_HASH2_MODULE 1

#define CONFIG_CRYPTO_RNG_MODULE 1

#define CONFIG_CRYPTO_RNG2_MODULE 1

#define CONFIG_CRYPTO_PCOMP_MODULE 1

#define CONFIG_CRYPTO_PCOMP2_MODULE 1

#define CONFIG_CRYPTO_MANAGER_MODULE 1

#define CONFIG_CRYPTO_MANAGER2_MODULE 1

#define CONFIG_CRYPTO_MANAGER_DISABLE_TESTS 1

#define CONFIG_CRYPTO_GF128MUL_MODULE 1

#define CONFIG_CRYPTO_NULL_MODULE 1

#define CONFIG_CRYPTO_WORKQUEUE_MODULE 1

#define CONFIG_CRYPTO_CRYPTD_MODULE 1

#define CONFIG_CRYPTO_AUTHENC_MODULE 1

#define CONFIG_CRYPTO_TEST_MODULE 1

#define CONFIG_CRYPTO_CCM_MODULE 1

#define CONFIG_CRYPTO_GCM_MODULE 1

#define CONFIG_CRYPTO_SEQIV_MODULE 1

#define CONFIG_CRYPTO_CBC_MODULE 1

#define CONFIG_CRYPTO_CTR_MODULE 1

#define CONFIG_CRYPTO_CTS_MODULE 1

#define CONFIG_CRYPTO_ECB_MODULE 1

#define CONFIG_CRYPTO_PCBC_MODULE 1

#define CONFIG_CRYPTO_HMAC_MODULE 1

#define CONFIG_CRYPTO_CRC32C_MODULE 1

#define CONFIG_CRYPTO_GHASH_MODULE 1

#define CONFIG_CRYPTO_MD4_MODULE 1

#define CONFIG_CRYPTO_MD5_MODULE 1

#define CONFIG_CRYPTO_MICHAEL_MIC_MODULE 1

#define CONFIG_CRYPTO_RMD128_MODULE 1

#define CONFIG_CRYPTO_RMD160_MODULE 1

#define CONFIG_CRYPTO_RMD256_MODULE 1

#define CONFIG_CRYPTO_RMD320_MODULE 1

#define CONFIG_CRYPTO_SHA1_MODULE 1

#define CONFIG_CRYPTO_SHA256_MODULE 1

#define CONFIG_CRYPTO_SHA512_MODULE 1

#define CONFIG_CRYPTO_TGR192_MODULE 1

#define CONFIG_CRYPTO_WP512_MODULE 1

#define CONFIG_CRYPTO_AES_MODULE 1

#define CONFIG_CRYPTO_ANUBIS_MODULE 1

#define CONFIG_CRYPTO_ARC4_MODULE 1

#define CONFIG_CRYPTO_BLOWFISH_MODULE 1

#define CONFIG_CRYPTO_BLOWFISH_COMMON_MODULE 1

#define CONFIG_CRYPTO_CAMELLIA_MODULE 1

#define CONFIG_CRYPTO_CAST5_MODULE 1

#define CONFIG_CRYPTO_CAST6_MODULE 1

#define CONFIG_CRYPTO_DES_MODULE 1

#define CONFIG_CRYPTO_FCRYPT_MODULE 1

#define CONFIG_CRYPTO_KHAZAD_MODULE 1

#define CONFIG_CRYPTO_SEED_MODULE 1

#define CONFIG_CRYPTO_SERPENT_MODULE 1

#define CONFIG_CRYPTO_TEA_MODULE 1

#define CONFIG_CRYPTO_TWOFISH_MODULE 1

#define CONFIG_CRYPTO_TWOFISH_COMMON_MODULE 1

#define CONFIG_CRYPTO_DEFLATE_MODULE 1

#define CONFIG_CRYPTO_ZLIB_MODULE 1

#define CONFIG_CRYPTO_LZO_MODULE 1

#define CONFIG_CRYPTO_ANSI_CPRNG_MODULE 1

#define CONFIG_CRYPTO_HW 1

#define CONFIG_BITREVERSE_MODULE 1

#define CONFIG_GENERIC_IO 1

#define CONFIG_CRC_CCITT_MODULE 1

#define CONFIG_CRC16_MODULE 1

#define CONFIG_CRC_T10DIF_MODULE 1

#define CONFIG_CRC_ITU_T_MODULE 1

#define CONFIG_CRC32_MODULE 1

#define CONFIG_CRC32_SLICEBY8 1

#define CONFIG_CRC7_MODULE 1

#define CONFIG_LIBCRC32C_MODULE 1

#define CONFIG_ZLIB_INFLATE_MODULE 1

#define CONFIG_ZLIB_DEFLATE_MODULE 1

#define CONFIG_LZO_COMPRESS_MODULE 1

#define CONFIG_LZO_DECOMPRESS_MODULE 1

#define CONFIG_HAS_IOMEM 1

#define CONFIG_HAS_IOPORT 1

#define CONFIG_DQL 1

#define CONFIG_NLATTR 1

#include <linux/fs.h>

#include <linux/slab.h>

#include <linux/dcache.h>

#include <linux/security.h>

#include <linux/pagemap.h>

#include <linux/backing-dev.h>

static struct kmem_cache *inode_cachep __read_mostly;

/*

 * Empty aops. Can be used for the cases where the user does not

 * define any of the address_space operations.

 */

const struct address_space_operations empty_aops = {

};

unsigned int get_next_ino(void)

{

	static unsigned int res = 0;

	return ++res;

}

/**

 * inode_init_always - perform inode structure intialisation

 * @sb: superblock inode belongs to

 * @inode: inode to initialise

 *

 * These are initializations that need to be done on every inode

 * allocation as the fields are not initialised by slab allocation.

 */

int inode_init_always(struct super_block *sb, struct inode *inode)

{

	static const struct inode_operations empty_iops;

	static const struct file_operations empty_fops;

	struct address_space *const mapping = &inode->i_data;

	inode->i_sb = sb;

	inode->i_blkbits = sb->s_blocksize_bits;

	inode->i_flags = 0;

	atomic_set(&inode->i_count, 1);

	inode->i_op = &empty_iops;

	inode->i_fop = &empty_fops;

	inode->__i_nlink = 1;

	inode->i_opflags = 0;

	inode->i_uid = 0;

	inode->i_gid = 0;

	atomic_set(&inode->i_writecount, 0);

	inode->i_size = 0;

	inode->i_blocks = 0;

	inode->i_bytes = 0;

	inode->i_generation = 0;

#ifdef CONFIG_QUOTA

	memset(&inode->i_dquot, 0, sizeof(inode->i_dquot));

#endif

	inode->i_pipe = NULL;

	inode->i_bdev = NULL;

	inode->i_cdev = NULL;

	inode->i_rdev = 0;

	inode->dirtied_when = 0;

	if (security_inode_alloc(inode))

		goto out;

	spin_lock_init(&inode->i_lock);

	lockdep_set_class(&inode->i_lock, &sb->s_type->i_lock_key);

	mutex_init(&inode->i_mutex);

	lockdep_set_class(&inode->i_mutex, &sb->s_type->i_mutex_key);

	atomic_set(&inode->i_dio_count, 0);

	mapping->a_ops = &empty_aops;

	mapping->host = inode;

	mapping->flags = 0;

	mapping_set_gfp_mask(mapping, GFP_HIGHUSER_MOVABLE);

	mapping->assoc_mapping = NULL;

	mapping->backing_dev_info = &default_backing_dev_info;

	mapping->writeback_index = 0;

	/*

	 * If the block_device provides a backing_dev_info for client

	 * inodes then use that.  Otherwise the inode share the bdev's

	 * backing_dev_info.

	 */

	if (sb->s_bdev) {

		struct backing_dev_info *bdi;

		bdi = sb->s_bdev->bd_inode->i_mapping->backing_dev_info;

		mapping->backing_dev_info = bdi;

	}

	inode->i_private = NULL;

	inode->i_mapping = mapping;

	INIT_LIST_HEAD(&inode->i_dentry);	/* buggered by rcu freeing */

#ifdef CONFIG_FS_POSIX_ACL

	inode->i_acl = inode->i_default_acl = ACL_NOT_CACHED;

#endif

#ifdef CONFIG_FSNOTIFY

	inode->i_fsnotify_mask = 0;

#endif

//	this_cpu_inc(nr_inodes);

	return 0;

out:

	return -ENOMEM;

}

static struct inode *alloc_inode(struct super_block *sb)

{

	struct inode *inode;

	if (sb->s_op->alloc_inode)

		inode = sb->s_op->alloc_inode(sb);

	else

		inode = kmem_cache_alloc(inode_cachep, GFP_KERNEL);

	if (!inode)

		return NULL;

	if (unlikely(inode_init_always(sb, inode))) {

		if (inode->i_sb->s_op->destroy_inode)

			inode->i_sb->s_op->destroy_inode(inode);

		else

			kmem_cache_free(inode_cachep, inode);

		return NULL;

	}

	return inode;

}

/**

 *	new_inode_pseudo 	- obtain an inode

 *	@sb: superblock

 *

 *	Allocates a new inode for given superblock.

 *	Inode wont be chained in superblock s_inodes list

 *	This means :

 *	- fs can't be unmount

 *	- quotas, fsnotify, writeback can't work

 */

struct inode *new_inode_pseudo(struct super_block *sb)

{

	struct inode *inode = alloc_inode(sb);

	if (inode) {

		spin_lock(&inode->i_lock);

		inode->i_state = 0;

		spin_unlock(&inode->i_lock);

		INIT_LIST_HEAD(&inode->i_sb_list);

	}

	return inode;

}

#include <linux/module.h>

const struct module_version_attribute no_modules[1] = {

		{

		.mattr	= {

			.attr	= {

				.name	= "version",

				.mode	= S_IRUGO,

			},

			.show	= __modver_version_show,

		},

		.module_name	= KBUILD_MODNAME,

		.version	= "V0",

	}

};

const struct module_version_attribute **__start___modver = &no_modules;

const struct module_version_attribute **__stop___modver  = &no_modules;

static ssize_t store_uevent(struct module_attribute *mattr,

			    struct module_kobject *mk,

			    const char *buffer, size_t count)

{

	sim_assert (false);

	return 0;

}

struct module_attribute module_uevent =

	__ATTR(uevent, 0200, NULL, store_uevent);

struct ctl_table usermodehelper_table[] = {

	{ }

};

int dmesg_restrict = 1;

#include "sim-assert.h"

struct proc_dir_entry *proc_mkdir(const char *name,

				  struct proc_dir_entry *parent)

{

  return proc_create_entry (name, S_IRUGO | S_IXUGO, parent);

}

void __raise_softirq_irqoff(unsigned int nr)

{

	//trace_softirq_raise(nr);

	or_softirq_pending(1UL << nr);

}

#include "sim.h"

#include "sim-assert.h"

#include <linux/fs.h>

ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,

				 struct pipe_inode_info *pipe, size_t len,

				 unsigned int flags)

{

	sim_assert (false);

	return 0;

}

#include <linux/export.h>

#include <linux/slab.h>

#include <linux/acct.h>

#include <linux/blkdev.h>

#include <linux/mount.h>

#include <linux/security.h>

#include <linux/writeback.h>		/* for the emergency remount stuff */

#include <linux/idr.h>

#include <linux/mutex.h>

#include <linux/backing-dev.h>

#include <linux/rculist_bl.h>

#include <linux/cleancache.h>

#include <linux/fsnotify.h>

#include <sim-assert.h>

int set_anon_super(struct super_block *s, void *data)

{

	  return 0;

}

struct super_block;

LIST_HEAD(super_blocks);

/**

 *	alloc_super	-	create new superblock

 *	@type:	filesystem type superblock should belong to

 *

 *	Allocates and initializes a new &struct super_block.  alloc_super()

 *	returns a pointer new superblock or %NULL if allocation had failed.

 */

static struct super_block *alloc_super(struct file_system_type *type)

{

	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);

	static const struct super_operations default_op;

	if (s) {

		if (security_sb_alloc(s)) {

			kfree(s);

			s = NULL;

			goto out;

		}

#ifdef CONFIG_SMP

		s->s_files = alloc_percpu(struct list_head);

		if (!s->s_files) {

			security_sb_free(s);

			kfree(s);

			s = NULL;

			goto out;

		} else {

			int i;

			for_each_possible_cpu(i)

				INIT_LIST_HEAD(per_cpu_ptr(s->s_files, i));

		}

#else

		INIT_LIST_HEAD(&s->s_files);

#endif

		s->s_bdi = &default_backing_dev_info;

		INIT_HLIST_NODE(&s->s_instances);

		INIT_HLIST_BL_HEAD(&s->s_anon);

		INIT_LIST_HEAD(&s->s_inodes);

		INIT_LIST_HEAD(&s->s_dentry_lru);

		INIT_LIST_HEAD(&s->s_inode_lru);

		spin_lock_init(&s->s_inode_lru_lock);

		INIT_LIST_HEAD(&s->s_mounts);

		init_rwsem(&s->s_umount);

		mutex_init(&s->s_lock);

		lockdep_set_class(&s->s_umount, &type->s_umount_key);

		/*

		 * The locking rules for s_lock are up to the

		 * filesystem. For example ext3fs has different

		 * lock ordering than usbfs:

		 */

		lockdep_set_class(&s->s_lock, &type->s_lock_key);

		/*

		 * sget() can have s_umount recursion.

		 *

		 * When it cannot find a suitable sb, it allocates a new

		 * one (this one), and tries again to find a suitable old

		 * one.

		 *

		 * In case that succeeds, it will acquire the s_umount

		 * lock of the old one. Since these are clearly distrinct

		 * locks, and this object isn't exposed yet, there's no

		 * risk of deadlocks.

		 *

		 * Annotate this by putting this lock in a different

		 * subclass.

		 */

		down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);

		s->s_count = 1;

		atomic_set(&s->s_active, 1);

		mutex_init(&s->s_vfs_rename_mutex);

		lockdep_set_class(&s->s_vfs_rename_mutex, &type->s_vfs_rename_key);

		mutex_init(&s->s_dquot.dqio_mutex);

		mutex_init(&s->s_dquot.dqonoff_mutex);

		init_rwsem(&s->s_dquot.dqptr_sem);

		init_waitqueue_head(&s->s_wait_unfrozen);

		s->s_maxbytes = MAX_NON_LFS;

		s->s_op = &default_op;

		s->s_time_gran = 1000000000;

		s->cleancache_poolid = -1;

		s->s_shrink.seeks = DEFAULT_SEEKS;

		s->s_shrink.shrink = 0; // prune_super;

		s->s_shrink.batch = 1024;

	}

out:

	return s;

}

/**

 *	deactivate_locked_super	-	drop an active reference to superblock

 *	@s: superblock to deactivate

 *

 *	Drops an active reference to superblock, converting it into a temprory

 *	one if there is no other active references left.  In that case we

 *	tell fs driver to shut it down and drop the temporary reference we

 *	had just acquired.

 *

 *	Caller holds exclusive lock on superblock; that lock is released.

 */

void deactivate_locked_super(struct super_block *s)

{

	struct file_system_type *fs = s->s_type;

	if (atomic_dec_and_test(&s->s_active)) {

		cleancache_invalidate_fs(s);

		fs->kill_sb(s);

		/* caches are now gone, we can safely kill the shrinker now */

		unregister_shrinker(&s->s_shrink);

		/*

		 * We need to call rcu_barrier so all the delayed rcu free

		 * inodes are flushed before we release the fs module.

		 */

		rcu_barrier();

		put_filesystem(fs);

		put_super(s);

	} else {

		up_write(&s->s_umount);

	}

}

/**

 *	sget	-	find or create a superblock

 *	@type:	filesystem type superblock should belong to

 *	@test:	comparison callback

 *	@set:	setup callback

 *	@data:	argument to each of them

 */

struct super_block *sget(struct file_system_type *type,

			int (*test)(struct super_block *,void *),

			int (*set)(struct super_block *,void *),

			void *data)

{

	struct super_block *s = NULL;

	struct hlist_node *node;

	struct super_block *old;

	int err;

retry:

	spin_lock(&sb_lock);

	if (test) {

		hlist_for_each_entry(old, node, &type->fs_supers, s_instances) {

			if (!test(old, data))

				continue;

			if (!grab_super(old))

				goto retry;

			if (s) {

				up_write(&s->s_umount);

				destroy_super(s);

				s = NULL;

			}

			down_write(&old->s_umount);

			if (unlikely(!(old->s_flags & MS_BORN))) {

				deactivate_locked_super(old);

				goto retry;

			}

			return old;

		}

	}

	if (!s) {

		spin_unlock(&sb_lock);

		s = alloc_super(type);

		if (!s)

			return ERR_PTR(-ENOMEM);

		goto retry;

	}

	err = set(s, data);

	if (err) {

		spin_unlock(&sb_lock);

		up_write(&s->s_umount);

		destroy_super(s);

		return ERR_PTR(err);

	}

	s->s_type = type;

	strlcpy(s->s_id, type->name, sizeof(s->s_id));

	list_add_tail(&s->s_list, &super_blocks);

	hlist_add_head(&s->s_instances, &type->fs_supers);

	spin_unlock(&sb_lock);

//	get_filesystem(type);

//	register_shrinker(&s->s_shrink);

	return s;

}

void kill_anon_super(struct super_block *sb)

{

}

//	sim_assert (0);

	return;

#include <linux/mm.h>

#include <linux/shrinker.h>

/*

 * Add a shrinker callback to be called from the vm

 */

void register_shrinker(struct shrinker *shrinker)

{

}

/*

 * Remove one

 */

void unregister_shrinker(struct shrinker *shrinker)

{

}

struct workqueue_struct *__alloc_workqueue_key(const char *fmt,

					       unsigned int flags,

					       int max_active,

					       struct lock_class_key *key,

					       const char *lock_name, ...)

{

	return 0;

}