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

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

嵌入式Linux

开发平台：

Unix_Linux

presto.c：源码内容
  1. /*
  2.  * intermezzo.c
  3.  *
  4.  * This file implements basic routines supporting the semantics
  5.  *
  6.  * Author: Peter J. Braam  <braam@cs.cmu.edu>
  7.  * Copyright (C) 1998 Stelias Computing Inc
  8.  * Copyright (C) 1999 Red Hat Inc.
  9.  *
  10.  */
  11. #include <linux/types.h>
  12. #include <linux/kernel.h>
  13. #include <linux/sched.h>
  14. #include <linux/fs.h>
  15. #include <linux/stat.h>
  16. #include <linux/errno.h>
  17. #include <linux/vmalloc.h>
  18. #include <linux/slab.h>
  19. #include <linux/locks.h>
  20. #include <asm/segment.h>
  21. #include <asm/uaccess.h>
  22. #include <linux/string.h>
  23. #include <linux/smp_lock.h>
  25. #include <linux/intermezzo_fs.h>
  26. #include <linux/intermezzo_upcall.h>
  27. #include <linux/intermezzo_psdev.h>
  28. #include <linux/intermezzo_kml.h>
  30. extern int presto_init_last_rcvd_file(struct presto_file_set *);
  31. extern int presto_init_lml_file(struct presto_file_set *);
  32. extern int presto_init_kml_file(struct presto_file_set *);
  34. int presto_walk(const char *name, struct nameidata *nd)
  35. {
  36.         int err;
  37.         /* we do not follow symlinks to support symlink operations 
  38.            correctly. The vfs should always hand us resolved dentries
  39.            so we should not be required to use LOOKUP_FOLLOW. At the
  40.    reintegrating end, lento again should be working with the 
  41.            resolved pathname and not the symlink. SHP
  42.            XXX: This code implies that direct symlinks do not work. SHP
  43.         */
  44.         unsigned int flags = LOOKUP_POSITIVE;
  46.         ENTRY;
  47.         err = 0;
  48.         if (path_init(name, flags, nd)) 
  49.                 err = path_walk(name, nd);
  50.         return err;
  51. }
  54. static inline int presto_dentry_is_fsetroot(struct dentry *dentry)
  55. {
  56.         return ((long) dentry->d_fsdata) & PRESTO_FSETROOT;
  57. }
  59. static inline struct presto_file_set *presto_dentry2fset(struct dentry *dentry)
  60. {
  61.         return (struct presto_file_set *)
  62.                 (((long) dentry->d_fsdata) - PRESTO_FSETROOT);
  63. }
  65. /* find the presto minor device for this inode */
  66. int presto_i2m(struct inode *inode)
  67. {
  68.         struct presto_cache *cache;
  69.         ENTRY;
  70.         cache = presto_get_cache(inode);
  71.         CDEBUG(D_PSDEV, "n");
  72.         if ( !cache ) {
  73.                 printk("PRESTO: BAD: cannot find cache for dev %d, ino %ldn",
  74.                        inode->i_dev, inode->i_ino);
  75.                 EXIT;
  76.                 return -1;
  77.         }
  78.         EXIT;
  79.         return cache->cache_psdev->uc_minor;
  80. }
  82. inline int presto_f2m(struct presto_file_set *fset)
  83. {
  84.         return fset->fset_cache->cache_psdev->uc_minor;
  86. }
  88. inline int presto_c2m(struct presto_cache *cache)
  89. {
  90.         return cache->cache_psdev->uc_minor;
  92. }
  94. int presto_has_all_data(struct inode *inode)
  95. {
  96.         ENTRY;
  98.         if ( (inode->i_size >> inode->i_sb->s_blocksize_bits) >
  99.              inode->i_blocks) {
  100.                 EXIT;
  101.                 return 0;
  102.         }
  103.         EXIT;
  104.         return 1;
  106. }
  108. /* find the fileset dentry for this dentry */
  109. struct presto_file_set *presto_fset(struct dentry *de)
  110. {
  111.         struct dentry *fsde;
  112.         ENTRY;
  113.         fsde = de;
  114.         for ( ; ; ) {
  115.                 if ( presto_dentry_is_fsetroot(fsde) ) {
  116.                         EXIT;
  117.                         return presto_dentry2fset(fsde);
  118.                 }
  119.                 /* are we at the cache "/" ?? */
  120.                 if ( fsde->d_parent == fsde ) {
  121.                         if ( !de->d_inode ) {
  122.                                 printk("Warning %*s has no fileset inode.n",
  123.                                        de->d_name.len, de->d_name.name);
  124.                         }
  125.                         /* better to return a BAD thing */
  126.                         EXIT;
  127.                         return NULL;
  128.                 }
  129.                 fsde = fsde->d_parent;
  130.         }
  131.         /* not reached */
  132.         EXIT;
  133.         return NULL;
  134. }
  136. /* XXX check this out */
  137. struct presto_file_set *presto_path2fileset(const char *name)
  138. {
  139.         struct nameidata nd;
  140.         struct presto_file_set *fileset;
  141.         int error;
  142.         ENTRY;
  144.         error = presto_walk(name, &nd);
  145.         if (!error) { 
  146. #if 0
  147.                 error = do_revalidate(nd.dentry);
  148. #endif
  149.                 if (!error) 
  150.                         fileset = presto_fset(nd.dentry); 
  151.                 path_release(&nd); 
  152.                 EXIT;
  153.         } else 
  154.                 fileset = ERR_PTR(error);
  156.         EXIT;
  157.         return fileset;
  158. }
  160. /* check a flag on this dentry or fset root.  Semantics:
  161.    - most flags: test if it is set
  162.    - PRESTO_ATTR, PRESTO_DATA return 1 if PRESTO_FSETINSYNC is set
  163. */
  164. int presto_chk(struct dentry *dentry, int flag)
  165. {
  166.         int minor;
  167.         struct presto_file_set *fset = presto_fset(dentry);
  169.         ENTRY;
  170.         minor = presto_i2m(dentry->d_inode);
  171.         if ( upc_comms[minor].uc_no_filter ) {
  172.                 EXIT;
  173.                 return ~0;
  174.         }
  176.         /* if the fileset is in sync DATA and ATTR are OK */
  177.         if ( fset &&
  178.              (flag == PRESTO_ATTR || flag == PRESTO_DATA) &&
  179.              (fset->fset_flags & FSET_INSYNC) ) {
  180.                 CDEBUG(D_INODE, "fset in sync (ino %ld)!n",
  181.                        fset->fset_mtpt->d_inode->i_ino);
  182.                 EXIT;
  183.                 return 1;
  184.         }
  186.         /* if it is a fsetroot, it's stored in the fset_flags */
  187.         if ( fset && presto_dentry_is_fsetroot(dentry) ) {
  188.                 EXIT;
  189.                 return fset->fset_data & flag;
  190.         }
  192.         EXIT;
  193.         return ((int)(long)dentry->d_fsdata & flag);
  194. }
  196. /* set a bit in the dentry flags */
  197. void presto_set(struct dentry *dentry, int flag)
  198. {
  200.         if ( dentry->d_inode ) {
  201.                 CDEBUG(D_INODE, "SET ino %ld, flag %xn",
  202.                        dentry->d_inode->i_ino, flag);
  203.         }
  205.         if ( presto_dentry_is_fsetroot(dentry)) {
  206.                 struct presto_file_set *fset = presto_dentry2fset(dentry);
  207.                 if (fset) {
  208.                         fset->fset_data |= flag;
  209.                         CDEBUG(D_INODE, "Setting fset->fset_data: now %xn",
  210.                                fset->fset_data);
  211.                 }
  212.         } else {
  213.                 CDEBUG(D_INODE, "Setting dentry->d_fsdatan");
  214.                 ((int)(long)dentry->d_fsdata) |= flag;
  215.         }
  216. }
  218. /* given a path: complete the closes on the fset */
  219. int lento_complete_closes(char *path)
  220. {
  221.         struct nameidata nd;
  222.         struct dentry *dentry;
  223.         int error;
  224.         struct presto_file_set *fset;
  225.         ENTRY;
  228.         error = presto_walk(path, &nd);
  229.         if (error) {
  230.                 EXIT;
  231.                 return error;
  232.         }
  234.         dentry = nd.dentry;
  236.         error = -ENXIO;
  237.         if ( !presto_ispresto(dentry->d_inode) ) {
  238.                 EXIT;
  239.                 goto out_complete;
  240.         }
  241.         
  242.         fset = presto_fset(dentry);
  243.         error = -EINVAL;
  244.         if ( !fset ) {
  245.                 printk("No fileset!n");
  246.                 EXIT;
  247.                 goto out_complete;
  248.         }
  249.         
  250.         /* transactions and locking are internal to this function */ 
  251.         error = presto_complete_lml(fset);
  252.         
  253.         EXIT;
  254.  out_complete:
  255.         path_release(&nd); 
  256.         return error;
  257. }       
  259. /* set the fset recno and offset to a given value */ 
  260. int lento_reset_fset(char *path, __u64 offset, __u32 recno)
  261. {
  262.         struct nameidata nd;
  263.         struct dentry *dentry;
  264.         int error;
  265.         struct presto_file_set *fset;
  266.         ENTRY;
  269.         error = presto_walk(path, &nd);
  270.         if (error)
  271.                 return error;
  273.         dentry = nd.dentry;
  275.         error = -ENXIO;
  276.         if ( !presto_ispresto(dentry->d_inode) ) {
  277.                 EXIT;
  278.                 goto out_complete;
  279.         }
  280.         
  281.         fset = presto_fset(dentry);
  282.         error = -EINVAL;
  283.         if ( !fset ) {
  284.                 printk("No fileset!n");
  285.                 EXIT;
  286.                 goto out_complete;
  287.         }
  289.         write_lock(&fset->fset_kml.fd_lock);
  290.         fset->fset_kml.fd_recno = recno;
  291.         fset->fset_kml.fd_offset = offset;
  292.         read_lock(&fset->fset_kml.fd_lock);
  293.         
  294.         EXIT;
  295.  out_complete:
  296.         path_release(&nd);
  297.         return error;
  298. }       
  302. /* given a path, write an LML record for it - thus must have root's 
  303.    group array settings, since lento is doing this 
  304. */ 
  305. int lento_write_lml(char *path,
  306.                      __u64 remote_ino, 
  307.                      __u32 remote_generation,
  308.                      __u32 remote_version,
  309.                      struct presto_version *remote_file_version)
  310. {
  311.         struct nameidata nd; 
  312.         struct rec_info rec;
  313.         struct dentry *dentry;
  314.         struct file file;
  315.         int error;
  316.         struct presto_file_set *fset;
  317.         ENTRY;
  319.         error = presto_walk(path, &nd);
  320.         if (error) {
  321.                 EXIT;
  322.                 return error;
  323.         }
  324.         dentry = nd.dentry;
  326.         file.f_dentry = dentry;
  327.         file.private_data = NULL;
  329.         error = -ENXIO;
  330.         if ( !presto_ispresto(dentry->d_inode) ) {
  331.                 EXIT;
  332.                 goto out_lml;
  333.         }
  334.         
  335.         fset = presto_fset(dentry);
  336.         error = -EINVAL;
  337.         if ( !fset ) {
  338.                 printk("No fileset!n");
  339.                 EXIT;
  340.                 goto out_lml;
  341.         }
  343.         
  344.         /* setting offset to -1 appends */
  345.         rec.offset = -1;
  346.         /* this only requires a transaction below which is automatic */
  347.         error = presto_write_lml_close(&rec, 
  348.                                        fset,
  349.                                        &file, 
  350.                                        remote_ino,
  351.                                        remote_generation,
  352.                                        remote_version,
  353.                                        remote_file_version);
  354.         
  355.         EXIT;
  356.  out_lml:
  357.         path_release(&nd);
  358.         return error;
  359. }       
  361. /* given a path: write a close record and cancel an LML record, finally
  362.    call truncate LML.  Lento is doing this so it goes in with uid/gid's 
  363.    root. 
  364. */ 
  365. int lento_cancel_lml(char *path, 
  366.                      __u64 lml_offset, 
  367.                      __u64 remote_ino, 
  368.                      __u32 remote_generation,
  369.                      __u32 remote_version, 
  370.                      struct lento_vfs_context *info)
  371. {
  372.         struct nameidata nd;
  373.         struct rec_info rec;
  374.         struct dentry *dentry;
  375.         int error;
  376.         struct presto_file_set *fset;
  377.         void *handle; 
  378.         struct presto_version new_ver;
  379.         ENTRY;
  382.         error = presto_walk(path, &nd);
  383.         if (error) {
  384.                 EXIT;
  385.                 return error;
  386.         }
  387.         dentry = nd.dentry;
  389.         error = -ENXIO;
  390.         if ( !presto_ispresto(dentry->d_inode) ) {
  391.                 EXIT;
  392.                 goto out_cancel_lml;
  393.         }
  394.         
  395.         fset = presto_fset(dentry);
  397.         error=-EINVAL;
  398.         if (fset==NULL) {
  399.                 printk("No fileset!n");
  400.                 EXIT;
  401.                 goto out_cancel_lml;
  402.         }
  403.         
  404.         /* this only requires a transaction below which is automatic */
  405.         handle = presto_trans_start(fset, dentry->d_inode, PRESTO_OP_RELEASE); 
  406.         if ( !handle ) {
  407.                 error = -ENOMEM; 
  408.                 EXIT; 
  409.                 goto out_cancel_lml; 
  410.         } 
  411.         
  412.         if (info->flags & LENTO_FL_CANCEL_LML) {
  413.                 error = presto_clear_lml_close(fset, lml_offset);
  414.                 if ( error ) {
  415.                         presto_trans_commit(fset, handle);
  416.                         EXIT; 
  417.                         goto out_cancel_lml;
  418.                 }
  419.         }
  422.         if (info->flags & LENTO_FL_WRITE_KML) {
  423.                 struct file file;
  424.                 file.private_data = NULL;
  425.                 file.f_dentry = dentry; 
  426.                 presto_getversion(&new_ver, dentry->d_inode);
  427.                 error = presto_journal_close(&rec, fset, &file, dentry, 
  428.                                              &new_ver);
  429.                 if ( error ) {
  430.                         EXIT; 
  431.                         presto_trans_commit(fset, handle);
  432.                         goto out_cancel_lml;
  433.                 }
  434.         }
  436.         if (info->flags & LENTO_FL_WRITE_EXPECT) {
  437.                 error = presto_write_last_rcvd(&rec, fset, info); 
  438.                 if ( error ) {
  439.                         EXIT; 
  440.                         presto_trans_commit(fset, handle);
  441.                         goto out_cancel_lml;
  442.                 }
  443.         }
  445.         presto_trans_commit(fset, handle);
  447.         if (info->flags & LENTO_FL_CANCEL_LML) {
  448.             presto_truncate_lml(fset); 
  449.         }
  450.                 
  452.  out_cancel_lml:
  453.         EXIT;
  454.         path_release(&nd); 
  455.         return error;
  456. }       
  459. /* given a path, operate on the flags in its dentry.  Used by downcalls */
  460. int presto_mark_dentry(const char *name, int and_flag, int or_flag, 
  461.                        int *res)
  462. {
  463.         struct nameidata nd;
  464.         struct dentry *dentry;
  465.         int error;
  467.         CDEBUG(D_INODE, "name: %s, and flag %x, or flag %xn",
  468.                name, and_flag, or_flag);
  470.         error = presto_walk(name, &nd);
  471.         if (error)
  472.                 return error;
  473.         dentry = nd.dentry;
  474.         CDEBUG(D_INODE, "dentry at %p, d_fsdata %pn", dentry, dentry->d_fsdata);
  476.         error = -ENXIO;
  477.         if ( !presto_ispresto(dentry->d_inode) )
  478.                 goto out;
  480.         error = 0;
  481.         if ( presto_dentry_is_fsetroot(dentry) ) {
  482.                 struct presto_file_set *fset = presto_dentry2fset(dentry);
  483.                 CDEBUG(D_INODE, "Setting fset fset_data: fset %pn", fset);
  484.                 if ( fset ) {
  485.                         fset->fset_data &= and_flag;
  486.                         fset->fset_data |= or_flag;
  487.                         if (res) {
  488.                                 *res = fset->fset_data;
  489.                         }
  490.                 }
  491.                 CDEBUG(D_INODE, "fset %p, flags %x data %xn", 
  492.                        fset, fset->fset_flags, fset->fset_data);
  493.         } else {
  494.                 ((int)(long)dentry->d_fsdata) &= and_flag;
  495.                 ((int)(long)dentry->d_fsdata) |= or_flag;
  496.                 if (res) 
  497.                         *res = (int)(long)dentry->d_fsdata;
  498.         }
  500.         /* indicate if we were the only users while changing the flag */
  501.         if ( atomic_read(&dentry->d_count) > 1 )
  502.                 error = -EBUSY;
  504. out:
  505.         path_release(&nd);
  506.         return error;
  507. }
  509. /* given a path, operate on the flags in its cache.  Used by mark_ioctl */
  510. int presto_mark_cache(const char *name, int and_flag, int or_flag, 
  511.                       int *res)
  512. {
  513.         struct nameidata nd;
  514.         struct dentry *dentry;
  515.         struct presto_cache *cache;
  516.         int error;
  518.         CDEBUG(D_INODE,
  519.                "presto_mark_cache :: name: %s, and flag %x, or flag %xn",
  520.                name, and_flag, or_flag);
  522.         error = presto_walk(name, &nd);
  523.         if (error)
  524.                 return error;
  526.         dentry = nd.dentry;
  527.         error = -ENXIO;
  528.         if ( !presto_ispresto(dentry->d_inode) )
  529.                 goto out;
  531.         error = -EBADF;
  532.         cache = presto_get_cache(dentry->d_inode);
  533.         if ( !cache ) {
  534.                 printk("PRESTO: BAD: cannot find cache in presto_mark_cachen");
  535.                 make_bad_inode(dentry->d_inode);
  536.                 goto out;
  537.         }
  538.         error = 0;
  539.         ((int)cache->cache_flags) &= and_flag;
  540.         ((int)cache->cache_flags) |= or_flag;
  541.         if (res) {
  542.                 *res = (int)cache->cache_flags;
  543.         }
  545. out:
  546.         path_release(&nd);
  547.         return error;
  548. }
  550. int presto_mark_fset_dentry(struct dentry *dentry, int and_flag, int or_flag, 
  551.                      int * res)
  552. {
  553.         int error;
  554.         struct presto_file_set *fset;
  556.         error = -ENXIO;
  557.         if ( !presto_ispresto(dentry->d_inode) )
  558.                 return error;
  560.         error = -EBADF;
  561.         fset = presto_fset(dentry);
  562.         if ( !fset ) {
  563.                 printk("PRESTO: BAD: cannot find cache in presto_mark_cachen");
  564.                 make_bad_inode(dentry->d_inode);
  565.                 return error;
  566.         }
  567.         error = 0;
  568.         ((int)fset->fset_flags) &= and_flag;
  569.         ((int)fset->fset_flags) |= or_flag;
  570.         if (res) { 
  571.                 *res = (int)fset->fset_flags;
  572.         }
  574.         return error;
  575. }
  577. /* given a path, operate on the flags in its cache.  Used by mark_ioctl */
  578. inline int presto_mark_fset(const char *name, int and_flag, int or_flag, 
  579.                      int * res)
  580. {
  581.         struct nameidata nd;
  582.         struct dentry *dentry;
  583.         int error;
  584.         ENTRY;
  586.         error = presto_walk(name, &nd);
  587.         if (error)
  588.                 return error;
  591.         dentry = nd.dentry;
  592.         error = presto_mark_fset_dentry(dentry, and_flag, or_flag, res);
  594.         path_release(&nd);
  595.         return error;
  596. }
  599. /* talk to Lento about the permit */
  600. static int presto_permit_upcall(struct dentry *dentry)
  601. {
  602.         int rc;
  603.         char *path, *buffer;
  604.         int pathlen;
  605.         int minor;
  606.         int fsetnamelen;
  607.         struct presto_file_set *fset = NULL;
  609.         if ( (minor = presto_i2m(dentry->d_inode)) < 0)
  610.                 return -EINVAL;
  612.         fset = presto_fset(dentry);
  613.         if (!fset) {
  614.                 EXIT;
  615.                 return -ENOTCONN;
  616.         }
  617.         
  618.         if ( !presto_lento_up(minor) ) {
  619.                 if ( fset->fset_flags & FSET_STEAL_PERMIT ) {
  620.                         return 0;
  621.                 } else {
  622.                         return -ENOTCONN;
  623.                 }
  624.         }
  626.         PRESTO_ALLOC(buffer, char *, PAGE_SIZE);
  627.         if ( !buffer ) {
  628.                 printk("PRESTO: out of memory!n");
  629.                 return -ENOMEM;
  630.         }
  631.         path = presto_path(dentry, fset->fset_mtpt, buffer, PAGE_SIZE);
  632.         pathlen = MYPATHLEN(buffer, path);
  633.         fsetnamelen = strlen(fset->fset_name); 
  634.         rc = lento_permit(minor, pathlen, fsetnamelen, path, fset->fset_name);
  635.         PRESTO_FREE(buffer, PAGE_SIZE);
  636.         return rc;
  637. }
  639. /* get a write permit for the fileset of this inode
  640.  *  - if this returns a negative value there was an error
  641.  *  - if 0 is returned the permit was already in the kernel -- or --
  642.  *    Lento gave us the permit without reintegration
  643.  *  - lento returns the number of records it reintegrated 
  644.  */
  645. int presto_get_permit(struct inode * inode)
  646. {
  647.         struct dentry *de;
  648.         struct presto_file_set *fset;
  649.         int minor = presto_i2m(inode);
  650.         int rc;
  652.         ENTRY;
  653.         if (minor < 0) {
  654.                 EXIT;
  655.                 return -1;
  656.         }
  658.         if ( ISLENTO(minor) ) {
  659.                 EXIT;
  660.                 return -EINVAL;
  661.         }
  663.         if (list_empty(&inode->i_dentry)) {
  664.                 printk("No alias for inode %dn", (int) inode->i_ino);
  665.                 EXIT;
  666.                 return -EINVAL;
  667.         }
  669.         de = list_entry(inode->i_dentry.next, struct dentry, d_alias);
  671.         fset = presto_fset(de);
  672.         if ( !fset ) {
  673.                 printk("Presto: no fileset in presto_get_permit!n");
  674.                 EXIT;
  675.                 return -EINVAL;
  676.         }
  678.         if (fset->fset_flags & FSET_HASPERMIT) {
  679.                 lock_kernel();
  680.                 fset->fset_permit_count++;
  681.                 CDEBUG(D_INODE, "permit count now %d, inode %lxn", 
  682.                        fset->fset_permit_count, inode->i_ino);
  683.                 unlock_kernel();
  684.                 EXIT;
  685.                 return 0;
  686.         } else {
  687. /* Allow reintegration to proceed without locks -SHP */
  688.                 rc = presto_permit_upcall(fset->fset_mtpt);
  689.                 lock_kernel();
  690.                 if ( !rc ) { 
  691.                  presto_mark_fset_dentry
  692. (fset->fset_mtpt, ~0, FSET_HASPERMIT, NULL);
  693.                  fset->fset_permit_count++;
  694.                 }
  695.                 CDEBUG(D_INODE, "permit count now %d, ino %lx (likely 1), rc %dn", 
  696.          fset->fset_permit_count, inode->i_ino, rc);
  697.                 unlock_kernel();
  698.                 EXIT;
  699.                 return rc;
  700.         }
  701. }
  703. int presto_put_permit(struct inode * inode)
  704. {
  705.         struct dentry *de;
  706.         struct presto_file_set *fset;
  707.         int minor = presto_i2m(inode);
  709.         ENTRY;
  710.         if (minor < 0) {
  711.                 EXIT;
  712.                 return -1;
  713.         }
  715.         if ( ISLENTO(minor) ) {
  716.                 EXIT;
  717.                 return -1;
  718.         }
  720.         if (list_empty(&inode->i_dentry)) {
  721.                 printk("No alias for inode %dn", (int) inode->i_ino);
  722.                 EXIT;
  723.                 return -1;
  724.         }
  726.         de = list_entry(inode->i_dentry.next, struct dentry, d_alias);
  728.         fset = presto_fset(de);
  729.         if ( !fset ) {
  730.                 printk("Presto: no fileset in presto_get_permit!n");
  731.                 EXIT;
  732.                 return -1;
  733.         }
  735.         lock_kernel();
  736.         if (fset->fset_flags & FSET_HASPERMIT) {
  737.                 if (fset->fset_permit_count > 0) fset->fset_permit_count--;
  738.                 else printk("Put permit while permit count is 0, inode %lx!n",
  739.                                 inode->i_ino); 
  740.         } else {
  741.          fset->fset_permit_count=0;
  742.          printk("Put permit while no permit, inode %lx, flags %x!n", 
  743.                 inode->i_ino, fset->fset_flags);
  744.         }
  746.         CDEBUG(D_INODE, "permit count now %d, inode %lxn", 
  747.          fset->fset_permit_count, inode->i_ino);
  749.         if (fset->fset_flags & FSET_PERMIT_WAITING &&
  750.                     fset->fset_permit_count == 0) {
  751.                 CDEBUG(D_INODE, "permit count now 0, ino %lx, notify Lenton", 
  752.                        inode->i_ino);
  753.                 presto_mark_fset_dentry(fset->fset_mtpt, ~FSET_PERMIT_WAITING, 0, NULL);
  754.                 presto_mark_fset_dentry(fset->fset_mtpt, ~FSET_HASPERMIT, 0, NULL);
  755.                 lento_release_permit(fset->fset_cache->cache_psdev->uc_minor,
  756.                                      fset->fset_permit_cookie);
  757.                 fset->fset_permit_cookie = 0; 
  758.         }
  759.         unlock_kernel();
  761.         EXIT;
  762.         return 0;
  763. }
  766. void presto_getversion(struct presto_version * presto_version,
  767.                        struct inode * inode)
  768. {
  769.         presto_version->pv_mtime = cpu_to_le64((__u64)inode->i_mtime);
  770.         presto_version->pv_ctime = cpu_to_le64((__u64)inode->i_ctime);
  771.         presto_version->pv_size = cpu_to_le64((__u64)inode->i_size);
  772. }
  774. /*
  775.  *  note: this routine "pins" a dentry for a fileset root
  776.  */
  777. int presto_set_fsetroot(char *path, char *fsetname, unsigned int fsetid,
  778.                         unsigned int flags)
  779. {
  780.         struct presto_file_set *fset;
  781.         struct presto_file_set *fset2;
  782.         struct dentry *dentry;
  783.         struct presto_cache *cache;
  784.         int error;
  786.         ENTRY;
  788.         PRESTO_ALLOC(fset, struct presto_file_set *, sizeof(*fset));
  789.         error = -ENOMEM;
  790.         if ( !fset ) {
  791.                 printk(KERN_ERR "No memory allocating fset for %sn", fsetname);
  792.                 EXIT;
  793.                 return -ENOMEM;
  794.         }
  795.         CDEBUG(D_INODE, "fset at %pn", fset);
  797.         printk("presto: fsetroot: path %s, fileset name %sn", path, fsetname);
  798.         error = presto_walk(path, &fset->fset_nd);
  799.         CDEBUG(D_INODE, "n");
  800.         if (error) {
  801.                 EXIT;
  802.                 goto out_free;
  803.         }
  804.         dentry = fset->fset_nd.dentry;
  805.         CDEBUG(D_INODE, "n");
  807.         error = -ENXIO;
  808.         if ( !presto_ispresto(dentry->d_inode) ) {
  809.                 EXIT;
  810.                 goto out_dput;
  811.         }
  813.         CDEBUG(D_INODE, "n");
  814.         cache = presto_get_cache(dentry->d_inode);
  815.         if (!cache) {
  816.                 printk(KERN_ERR "No cache found for %sn", path);
  817.                 EXIT;
  818.                 goto out_dput;
  819.         }
  821.         CDEBUG(D_INODE, "n");
  822.         error = -EINVAL;
  823.         if ( !cache->cache_mtpt) {
  824.                 printk(KERN_ERR "Presto - no mountpoint: fsetroot fails!n");
  825.                 EXIT;
  826.                 goto out_dput;
  827.         }
  828.         CDEBUG(D_INODE, "n");
  830.         if (!cache->cache_root_fileset)  {
  831.                 printk(KERN_ERR "Presto - no file set: fsetroot fails!n");
  832.                 EXIT;
  833.                 goto out_dput;
  834.         }
  836.         error = -EEXIST;
  837.         CDEBUG(D_INODE, "n");
  838.         fset2 = presto_fset(dentry);
  839.         if (fset2 && (fset2->fset_mtpt == dentry) ) { 
  840.                 printk(KERN_ERR "Fsetroot already set (path %s)n", path);
  841.                 EXIT;
  842.                 goto out_dput;
  843.         }
  845.         fset->fset_cache = cache;
  846.         fset->fset_mtpt = dentry;
  847.         fset->fset_name = fsetname;
  848.         fset->fset_chunkbits = CHUNK_BITS;
  849.         fset->fset_flags = flags;
  850. fset->fset_file_maxio = FSET_DEFAULT_MAX_FILEIO; 
  852.         dentry->d_fsdata = (void *) ( ((long)fset) + PRESTO_FSETROOT );
  853.         list_add(&fset->fset_list, &cache->cache_fset_list);
  855.         error = presto_init_kml_file(fset);
  856.         if ( error ) {
  857.                 EXIT;
  858.                 CDEBUG(D_JOURNAL, "Error init_kml %dn", error);
  859.                 goto out_list_del;
  860.         }
  862.         error = presto_init_last_rcvd_file(fset);
  863.         if ( error ) {
  864.                 int rc;
  865.                 EXIT;
  866.                 rc = presto_close_journal_file(fset);
  867.                 CDEBUG(D_JOURNAL, "Error init_lastrcvd %d, cleanup %dn", error, rc);
  868.                 goto out_list_del;
  869.         }
  871.         error = presto_init_lml_file(fset);
  872.         if ( error ) {
  873.                 int rc;
  874.                 EXIT;
  875.                 rc = presto_close_journal_file(fset);
  876.                 CDEBUG(D_JOURNAL, "Error init_lml %d, cleanup %dn", error, rc);
  877.                 goto out_list_del;
  878.         }
  880. #ifdef  CONFIG_KREINT
  881.         /* initialize kml reint buffer */
  882.         error = kml_init (fset); 
  883.         if ( error ) {
  884.                 int rc;
  885.                 EXIT;
  886.                 rc = presto_close_journal_file(fset);
  887.                 CDEBUG(D_JOURNAL, "Error init kml reint %d, cleanup %dn", 
  888.                                 error, rc);
  889.                 goto out_list_del;
  890.         }
  891. #endif
  892.         if ( dentry->d_inode == dentry->d_inode->i_sb->s_root->d_inode) {
  893.                 cache->cache_flags |= CACHE_FSETROOT_SET;
  894.         }
  896.         CDEBUG(D_PIOCTL, "-------> fset at %p, dentry at %p, mtpt %p, fset %s, cache %p, d_fsdata %pn",
  897.                fset, dentry, fset->fset_mtpt, fset->fset_name, cache, dentry->d_fsdata);
  899.         EXIT;
  900.         return 0;
  902.  out_list_del:
  903.         list_del(&fset->fset_list);
  904.         dentry->d_fsdata = 0;
  905.  out_dput:
  906.         path_release(&fset->fset_nd); 
  907.  out_free:
  908.         PRESTO_FREE(fset, sizeof(*fset));
  909.         return error;
  910. }
  912. int presto_get_kmlsize(char *path, size_t *size)
  913. {
  914.         struct nameidata nd;
  915.         struct presto_file_set *fset;
  916.         struct dentry *dentry;
  917.         int error;
  919.         ENTRY;
  920.         error = presto_walk(path, &nd);
  921.         if (error) {
  922.                 EXIT;
  923.                 return error;
  924.         }
  925.         dentry = nd.dentry;
  927.         error = -ENXIO;
  928.         if ( !presto_ispresto(dentry->d_inode) ) {
  929.                 EXIT;
  930.                 goto kml_out;
  931.         }
  933.         error = -EINVAL;
  934.         if ( ! presto_dentry_is_fsetroot(dentry)) {
  935.                 EXIT;
  936.                 goto kml_out;
  937.         }
  939.         fset = presto_dentry2fset(dentry);
  940.         if (!fset) {
  941.                 EXIT;
  942.                 goto kml_out;
  943.         }
  944.         error = 0;
  945.         *size = fset->fset_kml.fd_offset;
  947.  kml_out:
  948.         path_release(&nd);
  949.         return error;
  950. }
  952. int presto_clear_fsetroot(char *path)
  953. {
  954.         struct nameidata nd;
  955.         struct presto_file_set *fset;
  956.         struct dentry *dentry;
  957.         struct presto_cache *cache;
  958.         int error;
  960.         ENTRY;
  961.         error = presto_walk(path, &nd);
  962.         if (error) {
  963.                 EXIT;
  964.                 return error;
  965.         }
  966.         dentry = nd.dentry;
  968.         error = -ENXIO;
  969.         if ( !presto_ispresto(dentry->d_inode) ) {
  970.                 EXIT;
  971.                 goto put_out;
  972.         }
  974.         error = -EINVAL;
  975.         if ( ! presto_dentry_is_fsetroot(dentry)) {
  976.                 EXIT;
  977.                 goto put_out;
  978.         }
  980.         fset = presto_dentry2fset(dentry);
  981.         if (!fset) {
  982.                 EXIT;
  983.                 goto put_out;
  984.         }
  986. #ifdef  CONFIG_KREINT
  987.         error = kml_cleanup (fset);
  988.         if ( error ) {
  989.                 printk("InterMezzo: Closing kml for fset %s: %dn",
  990.                        fset->fset_name, error);
  991.         }
  992. #endif
  994.         error = presto_close_journal_file(fset);
  995.         if ( error ) {
  996.                 printk("InterMezzo: Closing journal for fset %s: %dn",
  997.                        fset->fset_name, error);
  998.         }
  999.         cache = fset->fset_cache;
  1000.         cache->cache_flags &= ~CACHE_FSETROOT_SET;
  1002.         list_del(&fset->fset_list);
  1003.         dentry->d_fsdata = 0;
  1004.         path_release(&fset->fset_nd);
  1005.         fset->fset_mtpt = NULL;
  1006.         PRESTO_FREE(fset->fset_name, strlen(fset->fset_name) + 1);
  1007.         PRESTO_FREE(fset, sizeof(*fset));
  1008.         EXIT;
  1010. put_out:
  1011.         path_release(&nd); /* for our lookup */
  1012.         return error;
  1013. }
  1015. int presto_clear_all_fsetroots(char *path)
  1016. {
  1017.         struct nameidata nd;
  1018.         struct presto_file_set *fset;
  1019.         struct dentry *dentry;
  1020.         struct presto_cache *cache;
  1021.         int error;
  1022.         struct list_head *tmp,*tmpnext;
  1025.         ENTRY;
  1026.         error = presto_walk(path, &nd);
  1027.         if (error) {
  1028.                 EXIT;
  1029.                 return error;
  1030.         }
  1031.         dentry = nd.dentry;
  1033.         error = -ENXIO;
  1034.         if ( !presto_ispresto(dentry->d_inode) ) {
  1035.                 EXIT;
  1036.                 goto put_out;
  1037.         }
  1039.         error = -EINVAL;
  1040.         if ( ! presto_dentry_is_fsetroot(dentry)) {
  1041.                 EXIT;
  1042.                 goto put_out;
  1043.         }
  1045.         fset = presto_dentry2fset(dentry);
  1046.         if (!fset) {
  1047.                 EXIT;
  1048.                 goto put_out;
  1049.         }
  1051.         cache = fset->fset_cache;
  1052.         cache = fset->fset_cache;
  1053.         cache->cache_flags &= ~CACHE_FSETROOT_SET;
  1055.         tmp = &cache->cache_fset_list;
  1056.         tmpnext = tmp->next;
  1057.         while ( tmpnext != &cache->cache_fset_list) {
  1058. tmp=tmpnext;
  1059.                 tmpnext=tmp->next;
  1060.                 fset = list_entry(tmp, struct presto_file_set, fset_list);
  1062.                 
  1063.                 error = presto_close_journal_file(fset);
  1064.                 if ( error ) {
  1065.                         printk("InterMezzo: Closing journal for fset %s: %dn",
  1066.                                fset->fset_name, error);
  1067.                 }
  1068.                 list_del(&fset->fset_list);
  1069.                 fset->fset_mtpt->d_fsdata = 0;
  1070.                 path_release(&fset->fset_nd);
  1071.                 fset->fset_mtpt = NULL;
  1072.                 PRESTO_FREE(fset->fset_name, strlen(fset->fset_name) +1);
  1073.                 PRESTO_FREE(fset, sizeof(*fset));
  1074.         }
  1076.         EXIT;
  1077.  put_out:
  1078.         path_release(&nd); /* for our lookup */
  1079.         return error;
  1080. }
  1083. int presto_get_lastrecno(char *path, off_t *recno)
  1084. {
  1085.         struct nameidata nd; 
  1086.         struct presto_file_set *fset;
  1087.         struct dentry *dentry;
  1088.         int error;
  1089.         ENTRY;
  1091.         error = presto_walk(path, &nd);
  1092.         if (error) {
  1093.                 EXIT;
  1094.                 return error;
  1095.         }
  1097.         dentry = nd.dentry;
  1099.         error = -ENXIO;
  1100.         if ( !presto_ispresto(dentry->d_inode) ) {
  1101.                 EXIT;
  1102.                 goto kml_out;
  1103.         }
  1105.         error = -EINVAL;
  1106.         if ( ! presto_dentry_is_fsetroot(dentry)) {
  1107.                 EXIT;
  1108.                 goto kml_out;
  1109.         }
  1111.         fset = presto_dentry2fset(dentry);
  1112.         if (!fset) {
  1113.                 EXIT;
  1114.                 goto kml_out;
  1115.         }
  1116.         error = 0;
  1117.         *recno = fset->fset_kml.fd_recno;
  1119.  kml_out:
  1120.         path_release(&nd);
  1121.         return error;
  1122. }
  1124. /* 
  1125.    if *cookie != 0, lento must wait for this cookie
  1126.    before releasing the permit, operations are in progress. 
  1127. */ 
  1128. int presto_permit_downcall( const char * path, int *cookie )
  1129. {
  1130.         int result;
  1131.         struct presto_file_set *fset; 
  1133.         fset = presto_path2fileset(path);
  1134.         if (IS_ERR(fset)) { 
  1135.                 EXIT;
  1136.                 return PTR_ERR(fset);
  1137.         }
  1139. lock_kernel();
  1140.         if (fset->fset_permit_count != 0) {
  1141.                 /* is there are previous cookie? */
  1142.                 if (fset->fset_permit_cookie == 0) {
  1143.                         CDEBUG(D_CACHE, "presto installing cookie 0x%x, %sn",
  1144.                                *cookie, path);
  1145.                         fset->fset_permit_cookie = *cookie;
  1146.                 } else {
  1147.                         *cookie = fset->fset_permit_cookie;
  1148.                         CDEBUG(D_CACHE, "presto has cookie 0x%x, %sn",
  1149.                                *cookie, path);
  1150.                 }
  1151.                 result = presto_mark_fset(path, 0, FSET_PERMIT_WAITING, NULL);
  1152.         } else {
  1153.                 *cookie = 0;
  1154.                 CDEBUG(D_CACHE, "presto releasing permit %sn", path);
  1155.                 result = presto_mark_fset(path, ~FSET_HASPERMIT, 0, NULL);
  1156.         }
  1157. unlock_kernel();
  1159.         return result;
  1160. }
  1162. inline int presto_is_read_only(struct presto_file_set * fset)
  1163. {
  1164.         int minor, mask;
  1165.         struct presto_cache *cache = fset->fset_cache;
  1167.         minor= cache->cache_psdev->uc_minor;
  1168.         mask= (ISLENTO(minor)? FSET_LENTO_RO : FSET_CLIENT_RO);
  1169.         if ( fset->fset_flags & mask )
  1170.                 return 1;
  1171.         mask= (ISLENTO(minor)? CACHE_LENTO_RO : CACHE_CLIENT_RO);
  1172.         return  ((cache->cache_flags & mask)? 1 : 0);
  1173. }