开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
super.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

super.c：源码内容
  1. /*
  2.  *  presto's super.c
  3.  *
  4.  *  Copyright (C) 1998 Peter J. Braam
  5.  *  Copyright (C) 2000 Stelias Computing, Inc.
  6.  *  Copyright (C) 2000 Red Hat, Inc.
  7.  *
  8.  *
  9.  */
  12. #include <stdarg.h>
  14. #include <asm/bitops.h>
  15. #include <asm/uaccess.h>
  16. #include <asm/system.h>
  18. #include <linux/errno.h>
  19. #include <linux/fs.h>
  20. #include <linux/ext2_fs.h>
  21. #include <linux/slab.h>
  22. #include <linux/vmalloc.h>
  23. #include <linux/sched.h>
  24. #include <linux/stat.h>
  25. #include <linux/string.h>
  26. #include <linux/locks.h>
  27. #include <linux/blkdev.h>
  28. #include <linux/init.h>
  29. #define __NO_VERSION__
  30. #include <linux/module.h>
  32. #include <linux/intermezzo_fs.h>
  33. #include <linux/intermezzo_upcall.h>
  34. #include <linux/intermezzo_psdev.h>
  36. #ifdef PRESTO_DEBUG
  37. long presto_vmemory = 0;
  38. long presto_kmemory = 0;
  39. #endif
  41. extern struct presto_cache *presto_init_cache(void);
  42. extern inline void presto_cache_add(struct presto_cache *cache, kdev_t dev);
  43. extern inline void presto_init_cache_hash(void);
  45. int presto_remount(struct super_block *, int *, char *);
  46. extern ssize_t presto_file_write(struct file *file, const char *buf, 
  47.                                  size_t size, loff_t *off);
  49. /*
  50.  *  Reading the super block.
  51.  *
  52.  *
  53.  *
  54.  */
  56. /* returns an allocated string, copied out from data if opt is found */
  57. static char *read_opt(const char *opt, char *data)
  58. {
  59.         char *value;
  60.         char *retval;
  62.         CDEBUG(D_SUPER, "option: %s, data %sn", opt, data);
  63.         if ( strncmp(opt, data, strlen(opt)) )
  64.                 return NULL;
  66.         if ( (value = strchr(data, '=')) == NULL )
  67.                 return NULL;
  69.         value++;
  70.         PRESTO_ALLOC(retval, char *, strlen(value) + 1);
  71.         if ( !retval ) {
  72.                 printk("InterMezzo: Out of memory!n");
  73.                 return NULL;
  74.         }
  76.         strcpy(retval, value);
  77.         CDEBUG(D_SUPER, "Assigned option: %s, value %sn", opt, retval);
  78.         return retval;
  79. }
  81. static void store_opt(char **dst, char *opt, char *defval)
  82. {
  83.         if (dst) {
  84.                 if (*dst) { 
  85.                         PRESTO_FREE(*dst, strlen(*dst) + 1);
  86.                 }
  87.                 *dst = opt;
  88.         } else {
  89.                 printk("presto: store_opt, error dst == NULLn"); 
  90.         }
  93.         if (!opt && defval) {
  94.                 char *def_alloced; 
  95.                 PRESTO_ALLOC(def_alloced, char *, strlen(defval)+1);
  96.                 strcpy(def_alloced, defval);
  97.                 *dst = def_alloced; 
  98.         }
  99. }
  102. /* Find the options for InterMezzo in "options", saving them into the
  103.  * passed pointers.  If the pointer is null, the option is discarded.
  104.  * Copy out all non-InterMezzo options into cache_data (to be passed
  105.  * to the read_super operation of the cache).  The return value will
  106.  * be a pointer to the end of the cache_data.
  107.  */
  108. static char *presto_options(char *options, char *cache_data,
  109.                             char **cache_type, char **fileset,
  110.                             char **prestodev,  char **mtpt)
  111. {
  112.         char *this_char;
  113.         char *cache_data_end = cache_data;
  115.         if (!options || !cache_data)
  116.                 return cache_data_end;
  118.         /* set the defaults */ 
  119.         store_opt(cache_type, NULL, "ext3"); 
  120.         store_opt(prestodev, NULL, PRESTO_PSDEV_NAME "0"); 
  122.         CDEBUG(D_SUPER, "parsing optionsn");
  123.         for (this_char = strtok (options, ",");
  124.              this_char != NULL;
  125.              this_char = strtok (NULL, ",")) {
  126.                 char *opt;
  127.                 CDEBUG(D_SUPER, "this_char %sn", this_char);
  129.                 if ( (opt = read_opt("fileset", this_char)) ) {
  130.                         store_opt(fileset, opt, NULL);
  131.                         continue;
  132.                 }
  133.                 if ( (opt = read_opt("cache_type", this_char)) ) {
  134.                         store_opt(cache_type, opt, "ext3");
  135.                         continue;
  136.                 }
  137.                 if ( (opt = read_opt("mtpt", this_char)) ) {
  138.                         store_opt(mtpt, opt, NULL);
  139.                         continue;
  140.                 }
  141.                 if ( (opt = read_opt("prestodev", this_char)) ) {
  142.                         store_opt(prestodev, opt, PRESTO_PSDEV_NAME);
  143.                         continue;
  144.                 }
  146.                 cache_data_end += sprintf(cache_data_end, "%s%s",
  147.                                           cache_data_end != cache_data ? ",":"",
  148.                                           this_char);
  149.         }
  151.         return cache_data_end;
  152. }
  154. /*
  155.     map a /dev/intermezzoX path to a minor:
  156.     used to validate mount options passed to InterMezzo
  157.  */
  158. static int presto_get_minor(char *dev_path, int *minor)
  159. {
  160.         struct nameidata nd;
  161.         struct dentry *dentry;
  162.         kdev_t devno = 0;
  163.         int error; 
  164.         ENTRY;
  166.         /* Special case for root filesystem - use minor 0 always. */
  167.         if ( current->pid == 1 ) {
  168.                 *minor = 0;
  169.                 return 0;
  170.         }
  172.         error = presto_walk(dev_path, &nd);
  173.         if (error) {
  174. EXIT;
  175.                 return error;
  176. }
  177.         dentry = nd.dentry;
  179. error = -ENODEV;
  180.         if (!dentry->d_inode) { 
  181. EXIT;
  182. goto out;
  183. }
  185.         if (!S_ISCHR(dentry->d_inode->i_mode)) {
  186. EXIT;
  187. goto out;
  188. }
  190.         devno = dentry->d_inode->i_rdev;
  191.         if ( MAJOR(devno) != PRESTO_PSDEV_MAJOR ) { 
  192. EXIT;
  193. goto out;
  194. }
  196.         if ( MINOR(devno) >= MAX_PRESTODEV ) {
  197. EXIT;
  198. goto out;
  199. }
  201. EXIT;
  202.  out:
  203.         *minor = MINOR(devno);
  204.         path_release(&nd);
  205.         return 0;
  206. }
  208. /* We always need to remove the presto options before passing to bottom FS */
  209. struct super_block * presto_read_super(struct super_block * presto_sb,
  210.                                        void * data, int silent)
  211. {
  212.         struct super_block *mysb = NULL;
  213.         struct file_system_type *fstype;
  214.         struct presto_cache *cache = NULL;
  215.         char *cache_data = NULL;
  216.         char *cache_data_end;
  217.         char *cache_type = NULL;
  218.         char *fileset = NULL;
  219.         char *presto_mtpt = NULL;
  220.         char *prestodev = NULL;
  221.         struct filter_fs *ops;
  222.         int minor;
  223.         struct upc_comm *psdev;
  225.         ENTRY;
  226.         CDEBUG(D_MALLOC, "before parsing: kmem %ld, vmem %ldn",
  227.                presto_kmemory, presto_vmemory);
  229.         /* reserve space for the cache's data */
  230.         PRESTO_ALLOC(cache_data, void *, PAGE_SIZE);
  231.         if ( !cache_data ) {
  232.                 printk("presto_read_super: Cannot allocate data page.n");
  233.                 EXIT;
  234.                 goto out_err;
  235.         }
  237.         CDEBUG(D_SUPER, "mount opts: %sn", data ? (char *)data : "(none)");
  239.         /* read and validate options */
  240.         cache_data_end = presto_options(data, cache_data, &cache_type, &fileset,
  241.                                         &prestodev, &presto_mtpt);
  243.         /* was there anything for the cache filesystem in the data? */
  244.         if (cache_data_end == cache_data) {
  245.                 PRESTO_FREE(cache_data, PAGE_SIZE);
  246.                 cache_data = NULL;
  247.         } else {
  248.                 CDEBUG(D_SUPER, "cache_data at %p is: %sn", cache_data,
  249.                        cache_data);
  250.         }
  252.         /* prepare the communication channel */
  253.         if ( presto_get_minor(prestodev, &minor) ) {
  254.                 /* if (!silent) */
  255.                 printk("InterMezzo: %s not a valid presto devn", prestodev);
  256.                 EXIT;
  257.                 goto out_err;
  258.         }
  259.         psdev = &upc_comms[minor];
  260.         CDEBUG(D_SUPER, "n");
  261.         psdev->uc_no_filter = 1;
  263.         CDEBUG(D_SUPER, "presto minor is %dn", minor);
  265.         /* set up the cache */
  266.         cache = presto_init_cache();
  267.         if ( !cache ) {
  268.                 printk("presto_read_super: failure allocating cache.n");
  269.                 EXIT;
  270.                 goto out_err;
  271.         }
  273.         /* no options were passed: likely we are "/" readonly */
  274.         if ( !presto_mtpt || !fileset ) {
  275.                 cache->cache_flags |= CACHE_LENTO_RO | CACHE_CLIENT_RO;
  276.         }
  277.         cache->cache_psdev = psdev;
  278.         /* no options were passed: likely we are "/" readonly */
  279.         /* before the journaling infrastructure can work, these
  280.            need to be set; that happens in presto_remount */
  281.         if ( !presto_mtpt || !fileset ) {
  282.                 if (!presto_mtpt) 
  283.                         printk("No mountpoint marking cache ROn");
  284.                 if (!fileset) 
  285.                         printk("No fileset marking cache ROn");
  286.                 cache->cache_flags |= CACHE_LENTO_RO | CACHE_CLIENT_RO;
  287.         }
  289.         cache->cache_mtpt = presto_mtpt;
  290.         cache->cache_root_fileset = fileset;
  291.         cache->cache_type = cache_type;
  293.         printk("Presto: type=%s, vol=%s, dev=%s (minor %d), mtpt %s, flags %xn",
  294.                cache_type, fileset ? fileset : "NULL", prestodev, minor,
  295.                presto_mtpt ? presto_mtpt : "NULL", cache->cache_flags);
  298.         MOD_INC_USE_COUNT;
  299.         fstype = get_fs_type(cache_type);
  301.         cache->cache_filter = filter_get_filter_fs((const char *)cache_type); 
  302.         if ( !fstype || !cache->cache_filter) {
  303.                 printk("Presto: unrecognized fs type or cache typen");
  304.                 MOD_DEC_USE_COUNT;
  305.                 EXIT;
  306.                 goto out_err;
  307.         }
  308.         mysb = fstype->read_super(presto_sb, cache_data, silent);
  309.         /* this might have been freed above */
  310.         if (cache_data) {
  311.                 PRESTO_FREE(cache_data, PAGE_SIZE);
  312.                 cache_data = NULL;
  313.         }
  314.         if ( !mysb ) {
  315.                 /* if (!silent) */
  316.                 printk("InterMezzo: cache mount failure.n");
  317.                 MOD_DEC_USE_COUNT;
  318.                 EXIT;
  319.                 goto out_err;
  320.         }
  323. cache->cache_sb = mysb;
  324.         ops = filter_get_filter_fs(cache_type);
  326.         filter_setup_journal_ops(cache->cache_filter, cache->cache_type); 
  328.         /* we now know the dev of the cache: hash the cache */
  329.         presto_cache_add(cache, mysb->s_dev);
  331.         /* make sure we have our own super operations: mysb
  332.            still contains the cache operations */
  333.         filter_setup_super_ops(cache->cache_filter, mysb->s_op, 
  334.                                &presto_super_ops);
  335.         mysb->s_op = filter_c2usops(cache->cache_filter);
  337.         /* now get our own directory operations */
  338.         if ( mysb->s_root && mysb->s_root->d_inode ) {
  339.                 CDEBUG(D_SUPER, "n");
  340.                 filter_setup_dir_ops(cache->cache_filter, 
  341.                                      mysb->s_root->d_inode,
  342.                                      &presto_dir_iops, &presto_dir_fops);
  343.                 mysb->s_root->d_inode->i_op = filter_c2udiops(cache->cache_filter);
  344.                 CDEBUG(D_SUPER, "lookup at %pn", 
  345.                        mysb->s_root->d_inode->i_op->lookup);
  346.                 filter_setup_dentry_ops(cache->cache_filter, 
  347.                                         mysb->s_root->d_op, 
  348.                                         &presto_dentry_ops);
  349.                 presto_sb->s_root->d_op = filter_c2udops(cache->cache_filter);
  350.                 cache->cache_mtde = mysb->s_root;
  351.         }
  353.         CDEBUG(D_MALLOC, "after mounting: kmem %ld, vmem %ldn",
  354.                presto_kmemory, presto_vmemory);
  356.         EXIT;
  357.         return mysb;
  359.  out_err:
  360.         CDEBUG(D_SUPER, "out_err calledn");
  361.         if (cache)
  362.                 PRESTO_FREE(cache, sizeof(struct presto_cache));
  363.         if (cache_data)
  364.                 PRESTO_FREE(cache_data, PAGE_SIZE);
  365.         if (fileset)
  366.                 PRESTO_FREE(fileset, strlen(fileset) + 1);
  367.         if (presto_mtpt)
  368.                 PRESTO_FREE(presto_mtpt, strlen(presto_mtpt) + 1);
  369.         if (prestodev)
  370.                 PRESTO_FREE(prestodev, strlen(prestodev) + 1);
  371.         if (cache_type)
  372.                 PRESTO_FREE(cache_type, strlen(cache_type) + 1);
  374.         CDEBUG(D_MALLOC, "mount error exit: kmem %ld, vmem %ldn",
  375.                presto_kmemory, presto_vmemory);
  376.         return NULL;
  377. }
  379. int presto_remount(struct super_block * sb, int *flags, char *data)
  380. {
  381.         char *cache_data = NULL;
  382.         char *cache_data_end;
  383.         char **type;
  384.         char **fileset;
  385.         char **mtpt;
  386.         char **prestodev;
  387.         struct super_operations *sops;
  388.         struct presto_cache *cache = NULL;
  389.         int err = 0;
  391.         ENTRY;
  392.         CDEBUG(D_MALLOC, "before remount: kmem %ld, vmem %ldn",
  393.                presto_kmemory, presto_vmemory);
  394.         CDEBUG(D_SUPER, "remount opts: %sn", data ? (char *)data : "(none)");
  395.         if (data) {
  396.                 /* reserve space for the cache's data */
  397.                 PRESTO_ALLOC(cache_data, void *, PAGE_SIZE);
  398.                 if ( !cache_data ) {
  399.                         err = -ENOMEM;
  400.                         EXIT;
  401.                         goto out_err;
  402.                 }
  403.         }
  405.         cache = presto_find_cache(sb->s_dev);
  406.         if (!cache) {
  407.                 printk(__FUNCTION__ ": cannot find cache on remountn");
  408.                 err = -ENODEV;
  409.                 EXIT;
  410.                 goto out_err;
  411.         }
  413.         /* If an option has not yet been set, we allow it to be set on
  414.          * remount.  If an option already has a value, we pass NULL for
  415.          * the option pointer, which means that the InterMezzo option
  416.          * will be parsed but discarded.
  417.          */
  418.         type = cache->cache_type ? NULL : &cache->cache_type;
  419.         fileset = cache->cache_root_fileset ? NULL : &cache->cache_root_fileset;
  420.         prestodev = cache->cache_psdev ? NULL : &cache->cache_psdev->uc_devname;
  421.         mtpt = cache->cache_mtpt ? NULL : &cache->cache_mtpt;
  422.         cache_data_end = presto_options(data, cache_data, type, fileset,
  423.                                         prestodev, mtpt);
  425.         if (cache_data) {
  426.                 if (cache_data_end == cache_data) {
  427.                         PRESTO_FREE(cache_data, PAGE_SIZE);
  428.                         cache_data = NULL;
  429.                 } else {
  430.                         CDEBUG(D_SUPER, "cache_data at %p is: %sn", cache_data,
  431.                                cache_data);
  432.                 }
  433.         }
  435.         if (cache->cache_root_fileset && cache->cache_mtpt) {
  436.                 cache->cache_flags &= ~(CACHE_LENTO_RO|CACHE_CLIENT_RO);
  437.         }
  439.         sops = filter_c2csops(cache->cache_filter);
  440.         if (sops->remount_fs) {
  441.                 err = sops->remount_fs(sb, flags, cache_data);
  442.         }
  444.         CDEBUG(D_MALLOC, "after remount: kmem %ld, vmem %ldn",
  445.                presto_kmemory, presto_vmemory);
  446.         EXIT;
  447. out_err:
  448.         if (cache_data)
  449.                 PRESTO_FREE(cache_data, PAGE_SIZE);
  450.         return err;
  451. }
  453. struct file_system_type presto_fs_type = {
  454. #ifdef PRESTO_DEVEL
  455.         "izofs",
  456. #else 
  457.         "intermezzo",
  458. #endif
  459.         FS_REQUIRES_DEV, /* can use Ibaskets when ext2 does */
  460.         presto_read_super,
  461.         NULL
  462. };
  465. int /* __init */ init_intermezzo_fs(void)
  466. {
  467.         int status;
  469.         printk(KERN_INFO "InterMezzo Kernel/Lento communications, "
  470.                "v1.04, braam@inter-mezzo.orgn");
  472.         status = presto_psdev_init();
  473.         if ( status ) {
  474.                 printk("Problem (%d) in init_intermezzo_psdevn", status);
  475.                 return status;
  476.         }
  478.         status = init_intermezzo_sysctl();
  479.         if (status) {
  480.                 printk("presto: failed in init_intermezzo_sysctl!n");
  481.         }
  483.         presto_init_cache_hash();
  485.         status = register_filesystem(&presto_fs_type);
  486.         if (status) {
  487.                 printk("presto: failed in register_filesystem!n");
  488.         }
  489.         return status;
  490. }
  493. #ifdef MODULE
  494. MODULE_AUTHOR("Peter J. Braam <braam@inter-mezzo.org>");
  495. MODULE_DESCRIPTION("InterMezzo Kernel/Lento communications, v1.0.5.1");
  497. int init_module(void)
  498. {
  499.         return init_intermezzo_fs();
  500. }
  503. void cleanup_module(void)
  504. {
  505.         int err;
  507.         ENTRY;
  509.         if ( (err = unregister_filesystem(&presto_fs_type)) != 0 ) {
  510.                 printk("presto: failed to unregister filesystemn");
  511.         }
  513.         presto_psdev_cleanup();
  514.         cleanup_intermezzo_sysctl();
  517. #ifdef PRESTO_DEVEL
  518.         unregister_chrdev(PRESTO_PSDEV_MAJOR, "intermezzo_psdev_devel");
  519. #else 
  520.         unregister_chrdev(PRESTO_PSDEV_MAJOR, "intermezzo_psdev");
  521. #endif
  522.         CDEBUG(D_MALLOC, "after cleanup: kmem %ld, vmem %ldn",
  523.                presto_kmemory, presto_vmemory);
  524. }
  526. #endif