/* set up the cache */        cache = presto_init_cache();        if ( !cache ) {                printk("presto_read_super: failure allocating cache.\n");                EXIT;                goto out_err;        }        /* no options were passed: likely we are "/" readonly */        if ( !presto_mtpt || !fileset ) {                cache->cache_flags |= CACHE_LENTO_RO | CACHE_CLIENT_RO;        }        cache->cache_psdev = psdev;        /* no options were passed: likely we are "/" readonly */        /* before the journaling infrastructure can work, these           need to be set; that happens in presto_remount */        if ( !presto_mtpt || !fileset ) {                if (!presto_mtpt)                         printk("No mountpoint marking cache RO\n");                if (!fileset)                         printk("No fileset marking cache RO\n");                cache->cache_flags |= CACHE_LENTO_RO | CACHE_CLIENT_RO;        }        cache->cache_mtpt = presto_mtpt;        cache->cache_root_fileset = fileset;        cache->cache_type = cache_type;        printk("Presto: type=%s, vol=%s, dev=%s (minor %d), mtpt %s, flags %x\n",               cache_type, fileset ? fileset : "NULL", prestodev, minor,               presto_mtpt ? presto_mtpt : "NULL", cache->cache_flags);        MOD_INC_USE_COUNT;        fstype = get_fs_type(cache_type);        cache->cache_filter = filter_get_filter_fs((const char *)cache_type);         if ( !fstype || !cache->cache_filter) {                printk("Presto: unrecognized fs type or cache type\n");                MOD_DEC_USE_COUNT;                EXIT;                goto out_err;        }        mysb = fstype->read_super(presto_sb, cache_data, silent);        /* this might have been freed above */        if (cache_data) {                PRESTO_FREE(cache_data, PAGE_SIZE);                cache_data = NULL;        }        if ( !mysb ) {                /* if (!silent) */                printk("InterMezzo: cache mount failure.\n");                MOD_DEC_USE_COUNT;                EXIT;                goto out_err;        }		cache->cache_sb = mysb;        ops = filter_get_filter_fs(cache_type);        filter_setup_journal_ops(cache->cache_filter, cache->cache_type);         /* we now know the dev of the cache: hash the cache */        presto_cache_add(cache, mysb->s_dev);        /* make sure we have our own super operations: mysb           still contains the cache operations */        filter_setup_super_ops(cache->cache_filter, mysb->s_op,                                &presto_super_ops);        mysb->s_op = filter_c2usops(cache->cache_filter);        /* now get our own directory operations */        if ( mysb->s_root && mysb->s_root->d_inode ) {                CDEBUG(D_SUPER, "\n");                filter_setup_dir_ops(cache->cache_filter,                                      mysb->s_root->d_inode,                                     &presto_dir_iops, &presto_dir_fops);                mysb->s_root->d_inode->i_op = filter_c2udiops(cache->cache_filter);                CDEBUG(D_SUPER, "lookup at %p\n",                        mysb->s_root->d_inode->i_op->lookup);                filter_setup_dentry_ops(cache->cache_filter,                                         mysb->s_root->d_op,                                         &presto_dentry_ops);                presto_sb->s_root->d_op = filter_c2udops(cache->cache_filter);                cache->cache_mtde = mysb->s_root;        }        CDEBUG(D_MALLOC, "after mounting: kmem %ld, vmem %ld\n",               presto_kmemory, presto_vmemory);        EXIT;        return mysb; out_err:        CDEBUG(D_SUPER, "out_err called\n");        if (cache)                PRESTO_FREE(cache, sizeof(struct presto_cache));        if (cache_data)                PRESTO_FREE(cache_data, PAGE_SIZE);        if (fileset)                PRESTO_FREE(fileset, strlen(fileset) + 1);        if (presto_mtpt)                PRESTO_FREE(presto_mtpt, strlen(presto_mtpt) + 1);        if (prestodev)                PRESTO_FREE(prestodev, strlen(prestodev) + 1);        if (cache_type)                PRESTO_FREE(cache_type, strlen(cache_type) + 1);        CDEBUG(D_MALLOC, "mount error exit: kmem %ld, vmem %ld\n",               presto_kmemory, presto_vmemory);        return NULL;}int presto_remount(struct super_block * sb, int *flags, char *data){        char *cache_data = NULL;        char *cache_data_end;        char **type;        char **fileset;        char **mtpt;        char **prestodev;        struct super_operations *sops;        struct presto_cache *cache = NULL;        int err = 0;        ENTRY;        CDEBUG(D_MALLOC, "before remount: kmem %ld, vmem %ld\n",               presto_kmemory, presto_vmemory);        CDEBUG(D_SUPER, "remount opts: %s\n", data ? (char *)data : "(none)");        if (data) {                /* reserve space for the cache's data */                PRESTO_ALLOC(cache_data, void *, PAGE_SIZE);                if ( !cache_data ) {                        err = -ENOMEM;                        EXIT;                        goto out_err;                }        }        cache = presto_find_cache(sb->s_dev);        if (!cache) {                printk(__FUNCTION__ ": cannot find cache on remount\n");                err = -ENODEV;                EXIT;                goto out_err;        }        /* If an option has not yet been set, we allow it to be set on         * remount.  If an option already has a value, we pass NULL for         * the option pointer, which means that the InterMezzo option         * will be parsed but discarded.         */        type = cache->cache_type ? NULL : &cache->cache_type;        fileset = cache->cache_root_fileset ? NULL : &cache->cache_root_fileset;        prestodev = cache->cache_psdev ? NULL : &cache->cache_psdev->uc_devname;        mtpt = cache->cache_mtpt ? NULL : &cache->cache_mtpt;        cache_data_end = presto_options(data, cache_data, type, fileset,                                        prestodev, mtpt);        if (cache_data) {                if (cache_data_end == cache_data) {                        PRESTO_FREE(cache_data, PAGE_SIZE);                        cache_data = NULL;                } else {                        CDEBUG(D_SUPER, "cache_data at %p is: %s\n", cache_data,                               cache_data);                }        }        if (cache->cache_root_fileset && cache->cache_mtpt) {                cache->cache_flags &= ~(CACHE_LENTO_RO|CACHE_CLIENT_RO);        }        sops = filter_c2csops(cache->cache_filter);        if (sops->remount_fs) {                err = sops->remount_fs(sb, flags, cache_data);        }        CDEBUG(D_MALLOC, "after remount: kmem %ld, vmem %ld\n",               presto_kmemory, presto_vmemory);        EXIT;out_err:        if (cache_data)                PRESTO_FREE(cache_data, PAGE_SIZE);        return err;}struct file_system_type presto_fs_type = {#ifdef PRESTO_DEVEL        "izofs",#else         "intermezzo",#endif        FS_REQUIRES_DEV, /* can use Ibaskets when ext2 does */        presto_read_super,        NULL};int /* __init */ init_intermezzo_fs(void){        int status;        printk(KERN_INFO "InterMezzo Kernel/Lento communications, "               "v1.04, braam@inter-mezzo.org\n");        status = presto_psdev_init();        if ( status ) {                printk("Problem (%d) in init_intermezzo_psdev\n", status);                return status;        }        status = init_intermezzo_sysctl();        if (status) {                printk("presto: failed in init_intermezzo_sysctl!\n");        }        presto_init_cache_hash();        status = register_filesystem(&presto_fs_type);        if (status) {                printk("presto: failed in register_filesystem!\n");        }        return status;}#ifdef MODULEMODULE_AUTHOR("Peter J. Braam <braam@inter-mezzo.org>");MODULE_DESCRIPTION("InterMezzo Kernel/Lento communications, v1.0.5.1");int init_module(void){        return init_intermezzo_fs();}void cleanup_module(void){        int err;        ENTRY;        if ( (err = unregister_filesystem(&presto_fs_type)) != 0 ) {                printk("presto: failed to unregister filesystem\n");        }        presto_psdev_cleanup();        cleanup_intermezzo_sysctl();#ifdef PRESTO_DEVEL        unregister_chrdev(PRESTO_PSDEV_MAJOR, "intermezzo_psdev_devel");#else         unregister_chrdev(PRESTO_PSDEV_MAJOR, "intermezzo_psdev");#endif        CDEBUG(D_MALLOC, "after cleanup: kmem %ld, vmem %ld\n",               presto_kmemory, presto_vmemory);}#endif