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

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

嵌入式Linux

开发平台：

Unix_Linux

intermezzo_fs.h：源码内容
  1. /*
  2.  *
  3.  *  This program is free software; you can redistribute it and/or
  4.  *  modify it under the terms of the GNU General Public License as
  5.  *  published by the Free Software Foundation; either version 2 of the
  6.  *  License, or (at your option) any later version.
  7.  *
  8.  *  Copyright (C) 2000 Stelias Computing, Inc.
  9.  *  Copyright (C) 2000 Red Hat, Inc.
  10.  *  Copyright (C) 2000 TurboLinux, Inc.
  11.  *  Copyright (C) 2000 Los Alamos National Laboratory.
  12.  *  Copyright (C) 2001 Tacitus Systems, Inc.
  13.  *  Copyright (C) 2001 Cluster File Systems, Inc. 
  14.  */
  16. #ifndef __INTERMEZZO_FS_H_
  17. #define __INTERMEZZO_FS_H_ 1
  19. #ifdef __KERNEL__
  20. #include <linux/smp.h>
  21. #include <linux/fsfilter.h>
  23. /* fixups for fs.h */
  24. #ifndef fs_down
  25. #define fs_down(sem) down(sem)
  26. #endif
  28. #ifndef fs_up
  29. #define fs_up(sem) up(sem)
  30. #endif
  32. /* We will be more tolerant than the default ea patch with attr name sizes and
  33.  * the size of value. If these come via VFS from the default ea patches, the
  34.  * corresponding character strings will be truncated anyway. During journalling- * we journal length for both name and value. See journal_set_ext_attr.
  35.  */
  36. #define PRESTO_EXT_ATTR_NAME_MAX 128
  37. #define PRESTO_EXT_ATTR_VALUE_MAX 8192
  39. #define KML_IDLE                        0
  40. #define KML_DECODE                      1
  41. #define KML_OPTIMIZE                    2
  42. #define KML_REINT                       3
  44. #define KML_OPEN_REINT                  0x0100
  45. #define KML_REINT_BEGIN                 0x0200
  46. #define KML_BACKFETCH                   0x0400
  47. #define KML_REINT_END                   0x0800
  48. #define KML_CLOSE_REINT                 0x1000
  49. #define FSET_GET_KMLDATA(fset)          fset->fset_kmldata
  50. #define KML_REINT_MAXBUF               (64 * 1024)
  52. struct  kml_fsdata
  53. {
  54.         int                kml_state;
  56.         /* kml optimize support */
  57.         struct list_head   kml_kop_cache;
  59.         /* kml reint support */
  60.         int                kml_reint_state;
  61.         struct list_head   kml_reint_cache;
  62.         struct list_head  *kml_reint_current;
  63.         int                kml_maxsize;  /* max buffer */
  64.         int                kml_len;
  65.         char *             kml_buf;
  66.         loff_t             kml_reintpos;
  67.         int                kml_count;
  68. };
  70. /* super.c */
  71. struct presto_cache *presto_find_cache(kdev_t dev) ;
  72. extern struct file_system_type presto_fs_type;
  73. extern int init_intermezzo_fs(void);
  75. #define CACHE_TYPE_LENGTH       16
  77. int presto_ispresto(struct inode *);
  79. #define CACHE_CLIENT_RO       0x4
  80. #define CACHE_LENTO_RO        0x8
  81. #define CACHE_FSETROOT_SET     0x10
  84. struct presto_cache {
  85.         spinlock_t         cache_lock; 
  86. loff_t             cache_reserved;
  87.         struct list_head cache_chain; /* for the dev/cache hash */
  89.         int   cache_flags;
  90.         char *cache_root_fileset;  /* fileset mounted on cache "/"  */
  92.         kdev_t cache_dev;            /* underlying block device */
  93. struct super_block *cache_sb;
  94.         struct dentry *cache_mtde;  /* unix mtpt of cache XXX NOT VALID XXX */
  95.         char *cache_mtpt;           /*  again */
  97.         char *cache_type;            /* filesystem type of cache */
  98.         struct filter_fs *cache_filter;
  100.         struct upc_comm *cache_psdev;  /* points to /dev/intermezzo? we use */
  101.         struct list_head cache_psdev_chain; 
  103.         struct list_head cache_fset_list; /* filesets mounted in cache */
  104. };
  109. /* file sets */
  110. #define CHUNK_BITS  16
  112. struct presto_log_fd {
  113.         rwlock_t         fd_lock; 
  114.         loff_t           fd_offset;  /* offset where next record should go */ 
  115.         struct file    *fd_file;
  116.         int             fd_truncating;
  117.         unsigned int   fd_recno;   /* last recno written */ 
  118.         struct list_head  fd_reservations;
  119. };
  121. struct presto_file_set {
  122.         struct list_head fset_list;
  123.         struct presto_log_fd fset_kml;
  124.         struct presto_log_fd fset_lml;
  125.         struct file *fset_last_rcvd;
  126.         struct dentry *fset_mtpt;
  127.         struct nameidata fset_nd; 
  128.         struct presto_cache *fset_cache;
  130.         unsigned int fset_lento_recno;  /* last recno mentioned to lento */
  131.         loff_t fset_lento_off;    /* last offset mentioned to lento */
  132.         char * fset_name;
  134.         int fset_flags;
  135.         int fset_permit_count;
  136.         int fset_permit_cookie;
  137.         int fset_chunkbits; 
  138.         int fset_data; /* replaces the dentry d_data field for fsetroots */
  139. struct  kml_fsdata *fset_kmldata;
  140. loff_t  fset_file_maxio;  /* writing more than this causes a close */ 
  141. };
  143. /* This is the default number of bytes written before a close is recorded*/
  144. #define FSET_DEFAULT_MAX_FILEIO (1024<<10)
  146. struct journal_ops {
  147.         loff_t (*tr_avail)(struct presto_cache *fset, struct super_block *);
  148.         void *(*tr_start)(struct presto_file_set *, struct inode *, int op);
  149.         void (*tr_commit)(struct presto_file_set *, void *handle);
  150.         void (*tr_journal_data)(struct inode *);
  151. };
  154. extern struct journal_ops presto_ext2_journal_ops;
  155. extern struct journal_ops presto_ext3_journal_ops;
  156. extern struct journal_ops presto_xfs_journal_ops;
  157. extern struct journal_ops presto_reiserfs_journal_ops;
  158. extern struct journal_ops presto_obdfs_journal_ops;
  159. struct lento_vfs_context {
  160.         __u32 slot_offset;
  161.         __u32 recno;
  162.         __u64 kml_offset;
  163.         __u32 flags;
  164.         __u32 updated_time;
  165. };
  168. #define LENTO_FL_KML            0x0001
  169. #define LENTO_FL_EXPECT         0x0002
  170. #define LENTO_FL_VFSCHECK       0x0004
  171. #define LENTO_FL_JUSTLOG        0x0008
  172. #define LENTO_FL_WRITE_KML      0x0010
  173. #define LENTO_FL_CANCEL_LML     0x0020
  174. #define LENTO_FL_WRITE_EXPECT   0x0040
  175. #define LENTO_FL_IGNORE_TIME    0x0080
  177. struct presto_cache *presto_get_cache(struct inode *inode) ;
  178. int presto_sprint_mounts(char *buf, int buflen, int minor);
  179. struct presto_file_set *presto_fset(struct dentry *de);
  180. int presto_journal(struct dentry *dentry, char *buf, size_t size);
  181. int presto_fwrite(struct file *file, const char *str, int len, loff_t *off);
  183. /* psdev.c */
  184. int presto_psdev_init(void);
  185. extern void presto_psdev_cleanup(void);
  186. inline int presto_lento_up(int minor);
  188. /* inode.c */
  189. extern struct super_operations presto_super_ops;
  190. extern int presto_excluded_gid; 
  191. #define PRESTO_EXCL_GID 4711
  192. void presto_set_ops(struct inode *inode, struct  filter_fs *filter);
  193. void presto_read_inode(struct inode *inode);
  194. void presto_put_super(struct super_block *);
  196. /* journal.c */
  197. void presto_trans_commit(struct presto_file_set *fset, void *handle);
  198. void *presto_trans_start(struct presto_file_set *fset, struct inode *inode,
  199.                            int op);
  201. /* dcache.c */
  202. void presto_frob_dop(struct dentry *de) ;
  203. char * presto_path(struct dentry *dentry, struct dentry *root,
  204.                    char *buffer, int buflen);
  205. extern struct dentry_operations presto_dentry_ops;
  209. /* dir.c */
  210. extern struct inode_operations presto_dir_iops;
  211. extern struct inode_operations presto_file_iops;
  212. extern struct inode_operations presto_sym_iops;
  213. extern struct file_operations presto_dir_fops;
  214. extern struct file_operations presto_file_fops;
  215. extern struct file_operations presto_sym_fops;
  216. int presto_setattr(struct dentry *de, struct iattr *iattr);
  217. extern int presto_ilookup_uid; 
  218. #define PRESTO_ILOOKUP_MAGIC "...ino:"
  219. #define PRESTO_ILOOKUP_SEP ':'
  221. struct dentry *presto_lookup(struct inode * dir, struct dentry *dentry);
  223. /* file.c */
  224. struct presto_reservation_data {
  225.         unsigned int ri_recno; 
  226.         loff_t ri_offset;
  227.         loff_t ri_size;
  228.         struct list_head ri_list;
  229. };
  232. struct presto_file_data { 
  233.         int fd_do_lml;
  234.         loff_t fd_lml_offset;
  235.         uid_t fd_fsuid;
  236.         gid_t fd_fsgid;
  237.         uid_t fd_uid;
  238.         gid_t fd_gid;
  239.         mode_t fd_mode;
  240.         int fd_ngroups;
  241.         size_t fd_bytes_written; /* Number of bytes written so far on this fd*/
  242.         gid_t fd_groups[NGROUPS_MAX];
  243. };
  246. /* presto.c and Lento::Downcall */
  247. struct presto_version {
  248.         __u64 pv_mtime;
  249.         __u64 pv_ctime;
  250.         __u64 pv_size;
  251. };
  252. int presto_walk(const char *name, struct nameidata *nd);
  253. int presto_clear_fsetroot(char *path);
  254. int presto_clear_all_fsetroots(char *path);
  255. int  presto_get_kmlsize(char *path, size_t *size);
  256. int  presto_get_lastrecno(char *path, off_t *size);
  257. int presto_set_fsetroot(char *path, char *fsetname, unsigned int fsetid,
  258.                        unsigned int flags);
  259. int presto_has_all_data(struct inode *inode);
  260. inline int presto_is_read_only(struct presto_file_set *);
  261. int presto_truncate_lml(struct presto_file_set *fset);
  262. int lento_write_lml(char *path,
  263.                      __u64 remote_ino, 
  264.                      __u32 remote_generation,
  265.                      __u32 remote_version,
  266.                     struct presto_version *remote_file_version);
  267. int lento_reset_fset(char *path, __u64 offset, __u32 recno);
  268. int lento_complete_closes(char *path);
  269. int lento_cancel_lml(char *path,
  270.                      __u64 lml_offset, 
  271.                      __u64 remote_ino, 
  272.                      __u32 remote_generation,
  273.                      __u32 remote_version, 
  274.                      struct lento_vfs_context *info);
  275. inline int presto_f2m(struct presto_file_set *fset);
  277. /* cache.c */
  278. #define PRESTO_REQLOW  (3 * 4096)
  279. #define PRESTO_REQHIGH (6 * 4096)
  280. void presto_release_space(struct presto_cache *cache, loff_t req);
  281. int presto_reserve_space(struct presto_cache *cache, loff_t req);
  283. /* NOTE: PRESTO_FSETROOT MUST be 0x1:
  284.    - if this bit is set dentry->d_fsdata points to a file_set
  285.    - the address of the file_set if d_fsdata - 1
  286. */
  288. #define PRESTO_FSETROOT         0x00000001 /* dentry is fileset root */
  289. #define PRESTO_DATA             0x00000002 /* cached data is valid */
  290. #define PRESTO_ATTR             0x00000004 /* attributes cached */
  292. #define EISFSETROOT             0x2001
  295. struct presto_file_set *presto_path2fileset(const char *name);
  296. int presto_permit_downcall(const char *path, int *cookie);
  297. int presto_chk(struct dentry *dentry, int flag);
  298. void presto_set(struct dentry *dentry, int flag);
  299. int presto_get_permit(struct inode *inode);
  300. int presto_put_permit(struct inode *inode);
  301. int presto_mark_dentry(const char *path, int and, int or, int *res);
  302. int presto_mark_cache(const char *path, int and_bits, int or_bits, int *);
  303. int presto_mark_fset(const char *path, int and_bits, int or_bits, int *);
  304. void presto_getversion(struct presto_version *pv, struct inode *inode);
  305. int presto_i2m(struct inode *inode);
  306. int presto_c2m(struct presto_cache *cache);
  308. /* journal.c */
  309. struct rec_info {
  310.         loff_t offset;
  311.         int size;
  312.         int recno;
  313.         int is_kml;
  314. };
  315. void presto_trans_commit(struct presto_file_set *fset, void *handle);
  316. void *presto_trans_start(struct presto_file_set *fset, struct inode *inode,
  317.                            int op);
  318. int presto_clear_lml_close(struct presto_file_set *fset, 
  319.                            loff_t  lml_offset);
  320. int presto_write_lml_close(struct rec_info *rec,
  321.                            struct presto_file_set *fset, 
  322.                            struct file *file,
  323.                            __u64 remote_ino,
  324.                            __u32 remote_generation,
  325.                            __u32 remote_version,
  326.                            struct presto_version *new_file_ver);
  327. int presto_complete_lml(struct presto_file_set *fset); 
  329. /* vfs.c */
  330. int presto_do_setattr(struct presto_file_set *fset, struct dentry *dentry,
  331.                       struct iattr *iattr, struct lento_vfs_context *info);
  332. int presto_do_create(struct presto_file_set *fset, struct dentry *dir,
  333.                      struct dentry *dentry, int mode,
  334.                      struct lento_vfs_context *info);
  335. int presto_do_link(struct presto_file_set *fset, struct dentry *dir,
  336.                    struct dentry *old_dentry, struct dentry *new_dentry,
  337.                    struct lento_vfs_context *info);
  338. int presto_do_unlink(struct presto_file_set *fset, struct dentry *dir,
  339.                      struct dentry *dentry, struct lento_vfs_context *info);
  340. int presto_do_symlink(struct presto_file_set *fset, struct dentry *dir,
  341.                       struct dentry *dentry, const char *name,
  342.                       struct lento_vfs_context *info);
  343. int presto_do_mkdir(struct presto_file_set *fset, struct dentry *dir,
  344.                     struct dentry *dentry, int mode,
  345.                     struct lento_vfs_context *info);
  346. int presto_do_rmdir(struct presto_file_set *fset, struct dentry *dir,
  347.                     struct dentry *dentry, struct lento_vfs_context *info);
  348. int presto_do_mknod(struct presto_file_set *fset, struct dentry *dir,
  349.                     struct dentry *dentry, int mode, dev_t dev,
  350.                     struct lento_vfs_context *info);
  351. int presto_do_rename(struct presto_file_set *fset, struct dentry *old_dir,
  352.                      struct dentry *old_dentry, struct dentry *new_dir,
  353.                      struct dentry *new_dentry, struct lento_vfs_context *info);
  355. int lento_setattr(const char *name, struct iattr *iattr,
  356.                   struct lento_vfs_context *info);
  357. int lento_create(const char *name, int mode, struct lento_vfs_context *info);
  358. int lento_link(const char *oldname, const char *newname,
  359.                struct lento_vfs_context *info);
  360. int lento_unlink(const char *name, struct lento_vfs_context *info);
  361. int lento_symlink(const char *oldname,const char *newname,
  362.                   struct lento_vfs_context *info);
  363. int lento_mkdir(const char *name, int mode, struct lento_vfs_context *info);
  364. int lento_rmdir(const char *name, struct lento_vfs_context *info);
  365. int lento_mknod(const char *name, int mode, dev_t dev,
  366.                 struct lento_vfs_context *info);
  367. int lento_rename(const char *oldname, const char *newname,
  368.                  struct lento_vfs_context *info);
  369. int lento_iopen(const char *name, ino_t ino, unsigned int generation,int flags);
  370. int lento_close(unsigned int fd, struct lento_vfs_context *info);
  373. /* journal.c */
  375. #define JOURNAL_PAGE_SZ  PAGE_SIZE
  377. __inline__ int presto_no_journal(struct presto_file_set *fset);
  378. int journal_fetch(int minor);
  379. int presto_journal_write(struct rec_info *rec, struct presto_file_set *fset,
  380.                          struct file *file);
  381. int presto_journal_setattr(struct rec_info *rec, struct presto_file_set *fset,
  382.                            struct dentry *dentry,
  383.                            struct presto_version *old_ver,
  384.                            struct iattr *iattr);
  385. int presto_journal_create(struct rec_info *rec, struct presto_file_set *fset,
  386.                           struct dentry *dentry,
  387.                           struct presto_version *tgt_dir_ver,
  388.                           struct presto_version *new_file_ver, int mode);
  389. int presto_journal_link(struct rec_info *rec, struct presto_file_set *fset,
  390.                         struct dentry *src, struct dentry *tgt,
  391.                         struct presto_version *tgt_dir_ver,
  392.                         struct presto_version *new_link_ver);
  393. int presto_journal_unlink(struct rec_info *rec, struct presto_file_set *fset,
  394.                           struct dentry *dentry,
  395.                           struct presto_version *tgt_dir_ver,
  396.                           struct presto_version *old_file_ver, int len,
  397.                           const char *name);
  398. int presto_journal_symlink(struct rec_info *rec, struct presto_file_set *fset,
  399.                            struct dentry *dentry, const char *target,
  400.                            struct presto_version *tgt_dir_ver,
  401.                            struct presto_version *new_link_ver);
  402. int presto_journal_mkdir(struct rec_info *rec, struct presto_file_set *fset,
  403.                          struct dentry *dentry,
  404.                          struct presto_version *tgt_dir_ver,
  405.                          struct presto_version *new_dir_ver, int mode);
  406. int presto_journal_rmdir(struct rec_info *rec, struct presto_file_set *fset,
  407.                          struct dentry *dentry,
  408.                          struct presto_version *tgt_dir_ver,
  409.                          struct presto_version *old_dir_ver, int len,
  410.                          const char *name);
  411. int presto_journal_mknod(struct rec_info *rec, struct presto_file_set *fset,
  412.                          struct dentry *dentry,
  413.                          struct presto_version *tgt_dir_ver,
  414.                          struct presto_version *new_node_ver, int mode,
  415.                          int dmajor, int dminor);
  416. int presto_journal_rename(struct rec_info *rec, struct presto_file_set *fset,
  417.                           struct dentry *src, struct dentry *tgt,
  418.                           struct presto_version *src_dir_ver,
  419.                           struct presto_version *tgt_dir_ver);
  420. int presto_journal_open(struct rec_info *rec, struct presto_file_set *fset,
  421.                         struct dentry *dentry, struct presto_version *old_ver);
  422. int presto_journal_close(struct rec_info *rec, struct presto_file_set *fset,
  423.                          struct file *file, 
  424.  struct dentry *dentry, 
  425.  struct presto_version *new_ver);
  426. int presto_close_journal_file(struct presto_file_set *fset);
  427. void presto_log_op(void *data, int len);
  428. int presto_write_last_rcvd(struct rec_info *recinfo,
  429.                            struct presto_file_set *fset,
  430.                            struct lento_vfs_context *info);
  432. /* journal_ext3.c */
  433. struct ext3_journal_data {
  434.         struct file *jd_file;
  435. };
  436. extern struct ext3_journal_data e3jd;
  441. /* sysctl.c */
  442. int init_intermezzo_sysctl(void);
  443. void cleanup_intermezzo_sysctl(void);
  445. /* ext_attr.c */
  446. #ifdef CONFIG_FS_EXT_ATTR
  447. /* XXX: Borrowed from vfs.c. Once the ea patch is into CVS 
  448.  * move this prototype -SHP
  449.  */
  450. int presto_do_set_ext_attr(struct presto_file_set *fset,
  451.                            struct dentry *dentry,
  452.                            const char *name, void *buffer,
  453.                            size_t buffer_len, int flags, mode_t *mode,
  454.                            struct lento_vfs_context *info);
  455. int presto_set_ext_attr(struct inode *inode,
  456.                         const char *name, void *buffer,
  457.                         size_t buffer_len, int flags);
  458. int lento_set_ext_attr(const char *path, const char *name,
  459.                        void *buffer, size_t buffer_len, int flags,
  460.                        mode_t mode, struct lento_vfs_context *info);
  461. /* XXX: Borrowed from journal.c. Once the ea patch is into CVS 
  462.  * move this prototype -SHP
  463.  */
  464. int presto_journal_set_ext_attr (struct rec_info *rec,
  465.                                  struct presto_file_set *fset,
  466.                                  struct dentry *dentry,
  467.                                  struct presto_version *ver, const char *name,
  468.                                  const char *buffer, int buffer_len,
  469.                                  int flags);
  470. #endif
  473. /* global variables */
  474. extern int presto_debug;
  475. extern int presto_print_entry;
  477. #define PRESTO_DEBUG
  478. #ifdef PRESTO_DEBUG
  479. /* debugging masks */
  480. #define D_SUPER     1   /* print results returned by Venus */
  481. #define D_INODE     2   /* print entry and exit into procedure */
  482. #define D_FILE      4
  483. #define D_CACHE     8   /* cache debugging */
  484. #define D_MALLOC    16  /* print malloc, de-alloc information */
  485. #define D_JOURNAL   32
  486. #define D_UPCALL    64  /* up and downcall debugging */
  487. #define D_PSDEV    128
  488. #define D_PIOCTL   256
  489. #define D_SPECIAL  512
  490. #define D_TIMING  1024
  491. #define D_DOWNCALL 2048
  492. #define D_KML      4096
  494. #define CDEBUG(mask, format, a...)                                      
  495.         do {                                                            
  496.                 if (presto_debug & mask) {                              
  497.                         printk("(%s:%s,l. %d %d): ", __FILE__, __FUNCTION__, __LINE__, current->pid);   
  498.                         printk(format, ##a); }                          
  499.         } while (0)
  501. #define ENTRY                                                           
  502.         if(presto_print_entry)                                          
  503.                 printk("Process %d entered %sn", current->pid, __FUNCTION__)
  505. #define EXIT                                                            
  506.         if(presto_print_entry)                                          
  507.                 printk("Process %d leaving %s at %dn", current->pid,   
  508.                        __FUNCTION__,__LINE__)
  510. extern long presto_kmemory;
  511. extern long presto_vmemory;
  513. #define presto_kmem_inc(ptr, size) presto_kmemory += (size)
  514. #define presto_kmem_dec(ptr, size) presto_kmemory -= (size)
  515. #define presto_vmem_inc(ptr, size) presto_vmemory += (size)
  516. #define presto_vmem_dec(ptr, size) presto_vmemory -= (size)
  517. #else /* !PRESTO_DEBUG */
  518. #define CDEBUG(mask, format, a...) do {} while (0)
  519. #define ENTRY do {} while (0)
  520. #define EXIT do {} while (0)
  521. #define presto_kmem_inc(ptr, size) do {} while (0)
  522. #define presto_kmem_dec(ptr, size) do {} while (0)
  523. #define presto_vmem_inc(ptr, size) do {} while (0)
  524. #define presto_vmem_dec(ptr, size) do {} while (0)
  525. #endif /* PRESTO_DEBUG */
  528. #define PRESTO_ALLOC(ptr, cast, size)                                   
  529. do {                                                                    
  530.     if (size <= 4096) {                                                 
  531.         ptr = (cast)kmalloc((unsigned long) size, GFP_KERNEL);          
  532.         CDEBUG(D_MALLOC, "kmalloced: %ld at %p.n", (long)size, ptr);   
  533.         presto_kmem_inc(ptr, size);                                     
  534.     } else {                                                            
  535.         ptr = (cast)vmalloc((unsigned long) size);                      
  536.         CDEBUG(D_MALLOC, "vmalloced: %ld at %p.n", (long)size, ptr);   
  537.         presto_vmem_inc(ptr, size);                                     
  538.     }                                                                   
  539.     if ((ptr) == 0)                                                     
  540.         printk("PRESTO: out of memory at %s:%dn", __FILE__, __LINE__); 
  541.     else                                                                
  542.         memset( ptr, 0, size );                                         
  543. } while (0)
  547. #define PRESTO_FREE(ptr,size)                                           
  548. do {                                                                    
  549.     if (!ptr) {                                                         
  550.         printk("PRESTO: free NULL pointer (%ld bytes) at %s:%dn",      
  551.                (long)size, __FILE__, __LINE__);                         
  552.         break;                                                          
  553.     }                                                                   
  554.     if (size <= 4096) {                                                 
  555.         CDEBUG(D_MALLOC, "kfreed: %ld at %p.n", (long)size, ptr);      
  556.         presto_kmem_dec(ptr, size);                                     
  557.         kfree((ptr));                                         
  558.     } else {                                                            
  559.         CDEBUG(D_MALLOC, "vfreed: %ld at %p.n", (long)size, ptr);      
  560.         presto_vmem_dec(ptr, size);                                     
  561.         vfree((ptr));                                                   
  562.     }                                                                   
  563. } while (0)
  565. #define MYPATHLEN(buffer,path) (buffer + PAGE_SIZE - path - 1)
  567. #else /* __KERNEL__ */
  568. #include <asm/types.h>
  569. #include <sys/ioctl.h>
  570. struct lento_vfs_context {
  571.         __u32 slot_offset;
  572.         __u32 recno;
  573.         __u64 kml_offset;
  574.         __u32 flags;
  575.         __u32 updated_time;
  576. };
  577. #endif /* __KERNEL__*/
  580. /* marking flags for fsets */
  581. #define FSET_CLIENT_RO 0x00000001
  582. #define FSET_LENTO_RO  0x00000002
  583. #define FSET_HASPERMIT  0x00000004 /* we have a permit to WB */
  584. #define FSET_INSYNC     0x00000008 /* this fileset is in sync */
  585. #define FSET_PERMIT_WAITING 0x00000010 /* Lento is waiting for permit */
  586. #define FSET_STEAL_PERMIT 0x00000020 /* take permit if Lento is dead */
  587. #define FSET_JCLOSE_ON_WRITE 0x00000040 /* Journal closes on writes */
  590. /* what to mark indicator (ioctl parameter) */ 
  591. #define MARK_DENTRY   101
  592. #define MARK_FSET     102
  593. #define MARK_CACHE    103
  594. #define MARK_GETFL    104
  598. struct readmount {
  599.         int io_len;  /* this is IN & OUT: true length of str is returned */
  600.         char *io_string;
  601. };
  603. /* modeled after setsockopt */
  604. /* so if you have no /proc, oh well. */
  605. /* for now it's all ints. We may grow this later for non-ints. */
  606. struct psdev_opt {
  607.         int optname;
  608.         int optval;
  609. };
  611. struct lento_input {
  612.         char *name;
  613.         struct lento_vfs_context info;
  614. };
  616. struct lento_input_attr {
  617.         char *name;
  618. #if BITS_PER_LONG < 64
  619.         __u32 dummy;    /* XXX on 64-bit platforms, this is not needed */
  620. #endif
  621.         __u32 valid;
  622.         __u32 mode;
  623.         __u32 uid;
  624.         __u32 gid;
  625.         __u64 size;
  626.         __s64 atime;
  627.         __s64 mtime;
  628.         __s64 ctime;
  629.         __u32 attr_flags;
  630.         struct lento_vfs_context info;
  631. };
  633. struct lento_input_mode {
  634.         char *name;
  635.         __u32 mode;
  636.         struct lento_vfs_context info;
  637. };
  639. struct lento_input_old_new {
  640.         char *oldname;
  641.         char *newname;
  642.         struct lento_vfs_context info;
  643. };
  645. struct lento_input_dev {
  646.         char *name;
  647.         __u32 mode;
  648.         __u32 major;
  649.         __u32 minor;
  650.         struct lento_vfs_context info;
  651. };
  653. struct lento_input_iopen {
  654.         char *name;
  655. #if BITS_PER_LONG < 64
  656.         __u32 dummy;    /* XXX on 64-bit platforms, this is not needed */
  657. #endif
  658.         __u64 ino;
  659.         __u32 generation;
  660.         __u32 flags;
  661.         __s32 fd;
  662. };
  664. struct lento_input_close {
  665.         __u32 fd;
  666.         struct lento_vfs_context info;
  667. };
  669. /* XXX: check for alignment */
  670. struct lento_input_ext_attr {
  671.         char  *path;
  672.         char  *name;
  673.         __u32 name_len;
  674.         char  *buffer;
  675.         __u32 buffer_len;
  676.         __u32 flags;
  677.         __u32 mode;
  678.         struct lento_vfs_context info;
  679. };
  681. /* XXX should PRESTO_GET_* actually be of type _IOR, since we are reading? */
  682. #define PRESTO_GETMOUNT         _IOW ('p',0x03, struct readmount *)
  683. #define PRESTO_SETPID           _IOW ('p',0x04, struct readmount *)
  684. #define PRESTO_CLOSE_JOURNALF   _IOW ('p',0x06, struct readmount *)
  685. #define PRESTO_SET_FSETROOT     _IOW ('p',0x07, struct readmount *)
  686. #define PRESTO_CLEAR_FSETROOT   _IOW ('p',0x08, struct readmount *)
  687. #define PRESTO_SETOPT           _IOW ('p',0x09, struct psdev_opt *)
  688. #define PRESTO_GETOPT           _IOW ('p',0x0a, struct psdev_opt *)
  689. #define PRESTO_GET_KMLSIZE      _IOW ('p',0x0b, struct psdev_opt *)
  690. #define PRESTO_GET_RECNO        _IOW ('p',0x0c, struct psdev_opt *)
  691. #define PRESTO_VFS_SETATTR      _IOW ('p',0x10, struct lento_input_attr *)
  692. #define PRESTO_VFS_CREATE       _IOW ('p',0x11, struct lento_input_mode *)
  693. #define PRESTO_VFS_LINK         _IOW ('p',0x12, struct lento_input_old_new *)
  694. #define PRESTO_VFS_UNLINK       _IOW ('p',0x13, struct lento_input *)
  695. #define PRESTO_VFS_SYMLINK      _IOW ('p',0x14, struct lento_input_old_new *)
  696. #define PRESTO_VFS_MKDIR        _IOW ('p',0x15, struct lento_input_mode *)
  697. #define PRESTO_VFS_RMDIR        _IOW ('p',0x16, struct lento_input *)
  698. #define PRESTO_VFS_MKNOD        _IOW ('p',0x17, struct lento_input_dev *)
  699. #define PRESTO_VFS_RENAME       _IOW ('p',0x18, struct lento_input_old_new *)
  700. #define PRESTO_VFS_CLOSE        _IOW ('p',0x1a, struct lento_input_close *)
  701. #define PRESTO_VFS_IOPEN        _IOW ('p',0x1b, struct lento_input_iopen *)
  702. #define PRESTO_VFS_SETEXTATTR   _IOW ('p',0x1c, struct lento_input_ext_attr *)
  703. #define PRESTO_VFS_DELEXTATTR   _IOW ('p',0x1d, struct lento_input_ext_attr *)
  705. #define PRESTO_MARK             _IOW ('p',0x20, struct lento_input_open *)
  706. #define PRESTO_RELEASE_PERMIT   _IOW ('p',0x21, struct lento_input_open *)
  707. #define PRESTO_CLEAR_ALL_FSETROOTS  _IOW ('p',0x22, struct readmount *)
  708. #define PRESTO_BACKFETCH_LML    _IOW ('p',0x23, struct readmount *)
  709. #define PRESTO_REINT            _IOW ('p',0x24, struct readmount *)
  710. #define PRESTO_CANCEL_LML       _IOW ('p',0x25, struct readmount *)
  711. #define PRESTO_RESET_FSET       _IOW ('p',0x26, struct readmount *)
  712. #define PRESTO_COMPLETE_CLOSES  _IOW ('p',0x27, struct readmount *)
  714. #define PRESTO_REINT_BEGIN      _IOW ('p',0x30, struct readmount *)
  715. #define PRESTO_DO_REINT         _IOW ('p',0x31, struct readmount *)
  716. #define PRESTO_REINT_END        _IOW ('p',0x32, struct readmount *)
  718. #endif