Inode cache
[akaros.git] / kern / include / vfs.h
1 /* Barret Rhoden <brho@cs.berkeley.edu>
2  *
3  * VFS, based on the Linux VFS as described in LKD 2nd Ed (Robert Love) and in
4  * UTLK (Bovet/Cesati) , which was probably written by Linus.  A lot of it was
5  * changed (reduced) to handle what ROS will need, at least initially.
6  * Hopefully it'll be similar enough to interface with ext2 and other Linux
7  * FSs.
8  *
9  * struct qstr came directly from Linux.
10  * Lawyers can sort out the copyrights and whatnot with these interfaces and
11  * structures. */
12
13 #ifndef ROS_KERN_VFS_H
14 #define ROS_KERN_VFS_H
15
16 #include <ros/common.h>
17 #include <sys/queue.h>
18 #include <arch/bitmask.h>
19 #include <kref.h>
20 #include <timing.h>
21 #include <radix.h>
22 #include <hashtable.h>
23 #include <blockdev.h>
24
25 /* ghetto preprocessor hacks (since proc includes vfs) */
26 struct page;
27 struct vm_region;
28
29 // TODO: temp typedefs, etc.  remove when we support this stuff.
30 typedef int dev_t;
31 typedef int kdev_t;
32 typedef int ino_t;
33 typedef long off_t; // out there in other .h's, but not in the kernel yet
34 struct io_writeback     {int x;};
35 struct event_poll {int x;};
36 struct poll_table_struct {int x;};
37 // end temp typedefs.  note ino and off_t are needed in the next include
38
39 #include <ros/fs.h>
40
41 struct page_map;        /* analagous to linux's address_space object */
42 struct page_map_operations;
43 struct super_block;
44 struct super_operations;
45 struct dentry;
46 struct dentry_operations;
47 struct inode;
48 struct inode_operations;
49 struct file;
50 struct file_operations;
51 struct fs_type;
52 struct vfsmount;
53
54 struct iovec {
55     void *iov_base;
56     size_t iov_len;
57 };
58
59 /* List def's we need */
60 TAILQ_HEAD(sb_tailq, super_block);
61 TAILQ_HEAD(dentry_tailq, dentry);
62 SLIST_HEAD(dentry_slist, dentry);
63 TAILQ_HEAD(inode_tailq, inode);
64 SLIST_HEAD(inode_slist, inode);
65 TAILQ_HEAD(file_tailq, file);
66 TAILQ_HEAD(io_wb_tailq, io_writeback);
67 TAILQ_HEAD(event_poll_tailq, event_poll);
68 TAILQ_HEAD(vfsmount_tailq, vfsmount);
69 TAILQ_HEAD(fs_type_tailq, fs_type); 
70
71 /* Linux's quickstring - saves recomputing the hash and length.  Note the length
72  * is the non-null-terminated length, as you'd get from strlen(). (for now) */
73 struct qstr {
74     unsigned int hash;
75     unsigned int len;
76     char *name;
77 };
78
79 /* Helpful structure to pass around during lookup operations.  At each point,
80  * it tracks the the answer, the name of the previous, how deep the symlink
81  * following has gone, and the symlink pathnames.  *dentry and *mnt up the
82  * refcnt of those objects too, so whoever 'receives; this will need to decref.
83  * This is meant to be pinning only the 'answer' to a path_lookup, and not the
84  * intermediate steps.  The intermediates get pinned due to the existence of
85  * their children in memory.  Internally, the VFS will refcnt any item whenever
86  * it is in this struct.  The last_sym is needed to pin the dentry (and thus the
87  * inode and char* storage for the symname) for the duration of a lookup.  When
88  * you resolve a pathname, you need to keep its string in memory. */
89 #define MAX_SYMLINK_DEPTH 6 // arbitrary.
90 struct nameidata {
91         struct dentry                           *dentry;                /* dentry of the obj */
92         struct vfsmount                         *mnt;                   /* its mount pt */
93         struct qstr                                     last;                   /* last component in search */
94         int                                                     flags;                  /* lookup flags */
95         int                                                     last_type;              /* type of last component */
96         unsigned int                            depth;                  /* search's symlink depth */
97         int                                                     intent;                 /* access type for the file */
98         struct dentry                           *last_sym;              /* pins the symname */
99 };
100
101 /* nameidata lookup flags and access type fields */
102 #define LOOKUP_FOLLOW           0x01    /* if the last is a symlink, follow */
103 #define LOOKUP_DIRECTORY        0x02    /* last component must be a directory */
104 #define LOOKUP_CONTINUE         0x04    /* still filenames to go */
105 #define LOOKUP_PARENT           0x08    /* lookup the dir that includes the item */
106 /* These are the nd's intent */
107 #define LOOKUP_OPEN             0x10    /* intent is to open a file */
108 #define LOOKUP_CREATE           0x11    /* create a file if it doesn't exist */
109 #define LOOKUP_ACCESS           0x12    /* access / check user permissions */
110
111 /* Every object that has pages, like an inode or the swap (or even direct block
112  * devices) has a page_map, tracking which of its pages are currently in memory.
113  * It is a map, per object, from index to physical page frame. */
114 struct page_map {
115         struct inode                            *pm_host;               /* inode of the owner, if any */
116         struct radix_tree                       pm_tree;                /* tracks present pages */
117         spinlock_t                                      pm_tree_lock;   /* spinlock => we can't block */
118         unsigned long                           pm_num_pages;   /* how many pages are present */
119         struct page_map_operations      *pm_op;
120         unsigned int                            pm_flags;
121         /*... and private lists, backing block dev info, other mappings, etc. */
122 };
123
124 /* Operations performed on a page_map.  These are usually FS specific, which
125  * get assigned when the inode is created.
126  * Will fill these in as they are created/needed/used. */
127 struct page_map_operations {
128         int (*readpage) (struct file *, struct page *); /* read from backing store*/
129 /*      readpages: read a list of pages
130         writepage: write from a page to its backing store
131         writepages: write a list of pages
132         sync_page: start the IO of already scheduled ops
133         set_page_dirty: mark the given page dirty
134         prepare_write: prepare to write (disk backed pages)
135         commit_write: complete a write (disk backed pages)
136         bmap: get a logical block number from a file block index
137         invalidate page: invalidate, part of truncating
138         release page: prepare to release 
139         direct_io: bypass the page cache */
140 };
141
142 /* Superblock: Specific instance of a mounted filesystem.  All synchronization
143  * is done with the one spinlock. */
144
145 struct super_block {
146         TAILQ_ENTRY(super_block)        s_list;                 /* list of all sbs */
147         dev_t                                           s_dev;                  /* id */
148         unsigned long                           s_blocksize;
149         bool                                            s_dirty;
150         unsigned long long                      s_maxbytes;             /* max file size */
151         struct fs_type                          *s_type;
152         struct super_operations         *s_op;
153         unsigned long                           s_flags;
154         unsigned long                           s_magic;
155         struct vfsmount                         *s_mount;               /* vfsmount point */
156         spinlock_t                                      s_lock;                 /* used for all sync */
157         struct kref                                     s_kref;
158         bool                                            s_syncing;              /* currently syncing metadata */
159         struct inode_tailq                      s_inodes;               /* all inodes */
160         struct inode_tailq                      s_dirty_i;              /* dirty inodes */
161         struct io_wb_tailq                      s_io_wb;                /* writebacks */
162         struct file_tailq                       s_files;                /* assigned files */
163         struct dentry_tailq                     s_lru_d;                /* unused dentries (in dcache)*/
164         spinlock_t                                      s_lru_lock;
165         struct hashtable                        *s_dcache;              /* dentry cache */
166         spinlock_t                                      s_dcache_lock;
167         struct hashtable                        *s_icache;              /* inode cache */
168         spinlock_t                                      s_icache_lock;
169         struct block_device                     *s_bdev;
170         TAILQ_ENTRY(super_block)        s_instances;    /* list of sbs of this fs type*/
171         char                                            s_name[32];
172         void                                            *s_fs_info;
173 };
174
175 struct super_operations {
176         struct inode *(*alloc_inode) (struct super_block *sb);
177         void (*dealloc_inode) (struct inode *);
178         void (*read_inode) (struct inode *);
179         void (*dirty_inode) (struct inode *);
180         void (*write_inode) (struct inode *, bool);
181         void (*put_inode) (struct inode *);                     /* when decreffed */
182         void (*drop_inode) (struct inode *);            /* when about to destroy */
183         void (*delete_inode) (struct inode *);          /* deleted from disk */
184         void (*put_super) (struct super_block *);       /* releases sb */
185         void (*write_super) (struct super_block *);     /* sync with sb on disk */
186         int (*sync_fs) (struct super_block *, bool);
187         int (*remount_fs) (struct super_block *, int, char *);
188         void (*umount_begin) (struct super_block *);/* called by NFS */
189 };
190
191 /* Sets the type of file, IAW the bits in ros/fs.h */
192 #define SET_FTYPE(mode, type) ((mode) = ((mode) & ~__S_IFMT) | (type))
193
194 /* Will need a bunch of states/flags for an inode.  TBD */
195 #define I_STATE_DIRTY                   0x001
196
197 /* Inode: represents a specific file */
198 struct inode {
199         SLIST_ENTRY(inode)                      i_hash;                 /* inclusion in a hash table */
200         TAILQ_ENTRY(inode)                      i_sb_list;              /* all inodes in the FS */
201         TAILQ_ENTRY(inode)                      i_list;                 /* describes state (dirty) */
202         struct dentry_tailq                     i_dentry;               /* all dentries pointing here*/
203         unsigned long                           i_ino;
204         struct kref                                     i_kref;
205         int                                                     i_mode;                 /* access mode and file type */
206         unsigned int                            i_nlink;                /* hard links */
207         uid_t                                           i_uid;
208         gid_t                                           i_gid;
209         kdev_t                                          i_rdev;                 /* real device node */
210         size_t                                          i_size;
211         unsigned long                           i_blksize;
212         unsigned long                           i_blocks;               /* filesize in blocks */
213         struct timespec                         i_atime;
214         struct timespec                         i_mtime;
215         struct timespec                         i_ctime;
216         spinlock_t                                      i_lock;
217         struct inode_operations         *i_op;
218         struct file_operations          *i_fop;
219         struct super_block                      *i_sb;
220         struct page_map                         *i_mapping;             /* usually points to i_data */
221         struct page_map                         i_pm;                   /* this inode's page cache */
222         union {
223                 struct pipe_inode_info          *i_pipe;
224                 struct block_device                     *i_bdev;
225                 struct char_device                      *i_cdev;
226         };
227         unsigned long                           i_state;
228         unsigned long                           dirtied_when;   /* in jiffies */
229         unsigned int                            i_flags;                /* filesystem mount flags */
230         bool                                            i_socket;
231         atomic_t                                        i_writecount;   /* number of writers */
232         void                                            *i_fs_info;
233 };
234
235 struct inode_operations {
236         int (*create) (struct inode *, struct dentry *, int, struct nameidata *);
237         struct dentry *(*lookup) (struct inode *, struct dentry *,
238                                   struct nameidata *);
239         int (*link) (struct dentry *, struct inode *, struct dentry *);
240         int (*unlink) (struct inode *, struct dentry *);
241         int (*symlink) (struct inode *, struct dentry *, const char *);
242         int (*mkdir) (struct inode *, struct dentry *, int);
243         int (*rmdir) (struct inode *, struct dentry *);
244         int (*mknod) (struct inode *, struct dentry *, int, dev_t);
245         int (*rename) (struct inode *, struct dentry *,
246                        struct inode *, struct dentry *);
247         char *(*readlink) (struct dentry *);
248         void (*truncate) (struct inode *);                      /* set i_size before calling */
249         int (*permission) (struct inode *, int, struct nameidata *);
250 };
251
252 #define DNAME_INLINE_LEN 32
253
254 /* Dentry flags.  All negatives are also unused. */
255 #define DENTRY_USED                     0x01    /* has a kref > 0 */
256 #define DENTRY_NEGATIVE         0x02    /* cache of a failed lookup */
257 #define DENTRY_DYING            0x04    /* should be freed on release */
258
259 /* Dentry: in memory object, corresponding to an element of a path.  E.g. /,
260  * usr, bin, and vim are all dentries.  All have inodes.  Vim happens to be a
261  * file instead of a directory.
262  * They can be used (valid inode, currently in use), unused (valid, not used),
263  * or negative (not a valid inode (deleted or bad path), but kept to resolve
264  * requests quickly.  If none of these, dealloc it back to the slab cache.
265  * Unused and negatives go in the LRU list. */
266 struct dentry {
267         struct kref                                     d_kref;                 /* don't discard when 0 */
268         unsigned long                           d_flags;                /* dentry cache flags */
269         spinlock_t                                      d_lock;
270         struct inode                            *d_inode;
271         TAILQ_ENTRY(dentry)                     d_lru;                  /* unused list */
272         TAILQ_ENTRY(dentry)                     d_alias;                /* linkage for i_dentry */
273         struct dentry_tailq                     d_subdirs;
274         TAILQ_ENTRY(dentry)                     d_subdirs_link;
275         unsigned long                           d_time;                 /* revalidate time (jiffies)*/
276         struct dentry_operations        *d_op;
277         struct super_block                      *d_sb;
278         bool                                            d_mount_point;  /* is an FS mounted over here */
279         struct vfsmount                         *d_mounted_fs;  /* fs mounted here */
280         struct dentry                           *d_parent;
281         struct qstr                                     d_name;                 /* pts to iname and holds hash*/
282         char                                            d_iname[DNAME_INLINE_LEN];
283         void                                            *d_fs_info;
284 };
285
286 /* not sure yet if we want to call delete when refcnt == 0 (move it to LRU) or
287  * when its time to remove it from the dcache. */
288 struct dentry_operations {
289         int (*d_revalidate) (struct dentry *, struct nameidata *);
290         int (*d_hash) (struct dentry *, struct qstr *);
291         int (*d_compare) (struct dentry *, struct qstr *, struct qstr *);
292         int (*d_delete) (struct dentry *);
293         int (*d_release) (struct dentry *);
294         void (*d_iput) (struct dentry *, struct inode *);
295 };
296
297 /* Yanked from glibc-2.11.1/posix/unistd.h */
298 #define SEEK_SET   0   /* Seek from beginning of file.  */
299 #define SEEK_CUR   1   /* Seek from current position.  */
300 #define SEEK_END   2   /* Seek from end of file.  */
301
302 /* File: represents a file opened by a process. */
303 struct file {
304         TAILQ_ENTRY(file)                       f_list;                 /* list of all files */
305         struct dentry                           *f_dentry;              /* definitely not inode.  =( */
306         struct vfsmount                         *f_vfsmnt;
307         struct file_operations          *f_op;
308         struct kref                                     f_kref;
309         unsigned int                            f_flags;                /* O_APPEND, etc */
310         int                                                     f_mode;                 /* O_RDONLY, etc */
311         off_t                                           f_pos;                  /* offset / file pointer */
312         unsigned int                            f_uid;
313         unsigned int                            f_gid;
314         int                                                     f_error;
315         struct event_poll_tailq         f_ep_links;
316         spinlock_t                                      f_ep_lock;
317         void                                            *f_fs_info;             /* tty driver hook */
318         struct page_map                         *f_mapping;             /* page cache mapping */
319
320         /* Ghetto appserver support */
321         int fd; // all it contains is an appserver fd (for pid 0, aka kernel)
322         int refcnt;
323         spinlock_t lock;
324 };
325
326 struct file_operations {
327         off_t (*llseek) (struct file *, off_t, int);
328         ssize_t (*read) (struct file *, char *, size_t, off_t *);
329         ssize_t (*write) (struct file *, const char *, size_t, off_t *);
330         int (*readdir) (struct file *, struct dirent *);
331         int (*mmap) (struct file *, struct vm_region *);
332         int (*open) (struct inode *, struct file *);
333         int (*flush) (struct file *);
334         int (*release) (struct inode *, struct file *);
335         int (*fsync) (struct file *, struct dentry *, int);
336         unsigned int (*poll) (struct file *, struct poll_table_struct *);
337         ssize_t (*readv) (struct file *, const struct iovec *, unsigned long,
338                           off_t *);
339         ssize_t (*writev) (struct file *, const struct iovec *, unsigned long,
340                           off_t *);
341         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, off_t, int);
342         int (*check_flags) (int flags);                         /* most FS's ignore this */
343 };
344
345 /* FS structs.  One of these per FS (e.g., ext2) */
346 struct fs_type {
347         const char                                      *name;
348         int                                                     fs_flags;
349         struct super_block                      *(*get_sb) (struct fs_type *, int,
350                                                 char *, struct vfsmount *);
351         void                                            (*kill_sb) (struct super_block *);
352         TAILQ_ENTRY(fs_type)            list;
353         struct sb_tailq                         fs_supers;              /* all of this FS's sbs */
354 };
355
356 /* A mount point: more focused on the mounting, and solely in memory, compared
357  * to the SB which is focused on FS definitions (and exists on disc). */
358 struct vfsmount {
359         TAILQ_ENTRY(vfsmount)           mnt_list;
360         struct vfsmount                         *mnt_parent;
361         struct dentry                           *mnt_mountpoint;/* parent dentry where mnted */
362         struct dentry                           *mnt_root;              /* dentry of root of this fs */
363         struct super_block                      *mnt_sb;
364         struct vfsmount_tailq           mnt_child_mounts;
365         TAILQ_ENTRY(vfsmount)           mnt_child_link;
366         struct kref                                     mnt_kref;
367         int                                                     mnt_flags;
368         char                                            *mnt_devname;
369         struct namespace                        *mnt_namespace;
370 };
371
372 /* Per-process structs */
373 #define NR_OPEN_FILES_DEFAULT 32
374 #define NR_FILE_DESC_DEFAULT 32
375 /* keep this in sync with glibc's fd_setsize */
376 #define NR_FILE_DESC_MAX 1024
377
378 /* Bitmask for file descriptors, big for when we exceed the initial small.  We
379  * could just use the fd_array to check for openness instead of the bitmask,
380  * but eventually we might want to use the bitmasks for other things (like
381  * which files are close_on_exec. */
382 struct fd_set {
383     uint8_t fds_bits[BYTES_FOR_BITMASK(NR_FILE_DESC_MAX)];
384 };
385 struct small_fd_set {
386     uint8_t fds_bits[BYTES_FOR_BITMASK(NR_FILE_DESC_DEFAULT)];
387 };
388
389 /* All open files for a process */
390 struct files_struct {
391         spinlock_t                                      lock;
392         int                                                     max_files;              /* max files ptd to by fd */
393         int                                                     max_fdset;              /* max of the current fd_set */
394         int                                                     next_fd;                /* next number available */
395         struct file                                     **fd;                   /* initially pts to fd_array */
396         struct fd_set                           *open_fds;              /* init, pts to open_fds_init */
397         struct small_fd_set                     open_fds_init;
398         struct file                                     *fd_array[NR_OPEN_FILES_DEFAULT];
399 };
400
401 /* Process specific filesysten info */
402 struct fs_struct {
403         spinlock_t                                      lock;
404         int                                                     umask;
405         struct dentry                           *root;
406         struct dentry                           *pwd;
407 };
408
409 /* Each process can have its own (eventually), but default to the same NS */
410 struct namespace {
411         struct kref                                     kref;
412         spinlock_t                                      lock;
413         struct vfsmount                         *root;
414         struct vfsmount_tailq           vfsmounts;      /* all vfsmounts in this ns */
415 };
416
417 /* Global Structs */
418 extern struct sb_tailq super_blocks;                    /* list of all sbs */
419 extern spinlock_t super_blocks_lock;
420 extern struct fs_type_tailq file_systems;               /* lock this if it's dynamic */
421 extern struct namespace default_ns;
422
423 /* Slab caches for common objects */
424 extern struct kmem_cache *dentry_kcache;
425 extern struct kmem_cache *inode_kcache;
426 extern struct kmem_cache *file_kcache;
427
428 /* Misc VFS functions */
429 void vfs_init(void);
430 void qstr_builder(struct dentry *dentry, char *l_name);
431 char *file_name(struct file *file);
432 int path_lookup(char *path, int flags, struct nameidata *nd);
433 void path_release(struct nameidata *nd);
434 int mount_fs(struct fs_type *fs, char *dev_name, char *path, int flags);
435
436 /* Superblock functions */
437 struct super_block *get_sb(void);
438 void init_sb(struct super_block *sb, struct vfsmount *vmnt,
439              struct dentry_operations *d_op, unsigned long root_ino,
440              void *d_fs_info);
441
442 /* Dentry Functions */
443 struct dentry *get_dentry(struct super_block *sb, struct dentry *parent,
444                           char *name);
445 void dentry_release(struct kref *kref);
446 void __dentry_free(struct dentry *dentry);
447 struct dentry *lookup_dentry(char *path, int flags);
448 struct dentry *dcache_get(struct super_block *sb, struct dentry *what_i_want);
449 void dcache_put(struct super_block *sb, struct dentry *key_val);
450 struct dentry *dcache_remove(struct super_block *sb, struct dentry *key);
451
452 /* Inode Functions */
453 struct inode *get_inode(struct dentry *dentry);
454 void load_inode(struct dentry *dentry, unsigned int ino);
455 int create_file(struct inode *dir, struct dentry *dentry, int mode);
456 int create_dir(struct inode *dir, struct dentry *dentry, int mode);
457 int create_symlink(struct inode *dir, struct dentry *dentry,
458                    const char *symname, int mode);
459 int check_perms(struct inode *inode, int access_mode);
460 void inode_release(struct kref *kref);
461 void stat_inode(struct inode *inode, struct kstat *kstat);
462 struct inode *icache_get(struct super_block *sb, unsigned int ino);
463 void icache_put(struct super_block *sb, struct inode *inode);
464 struct inode *icache_remove(struct super_block *sb, unsigned int ino);
465
466 /* File-ish functions */
467 ssize_t generic_file_read(struct file *file, char *buf, size_t count,
468                           off_t *offset);
469 ssize_t generic_file_write(struct file *file, const char *buf, size_t count,
470                            off_t *offset);
471 ssize_t generic_dir_read(struct file *file, char *u_buf, size_t count,
472                          off_t *offset);
473 struct file *do_file_open(char *path, int flags, int mode);
474 int do_symlink(char *path, const char *symname, int mode);
475 int do_link(char *old_path, char *new_path);
476 int do_unlink(char *path);
477 int do_access(char *path, int mode);
478 int do_chmod(char *path, int mode);
479 int do_mkdir(char *path, int mode);
480 int do_rmdir(char *path);
481 struct file *dentry_open(struct dentry *dentry, int flags);
482 void file_release(struct kref *kref);
483
484 /* Page cache functions */
485 struct page *pm_find_page(struct page_map *pm, unsigned long index);
486 int pm_insert_page(struct page_map *pm, unsigned long index, struct page *page);
487 int pm_remove_page(struct page_map *pm, struct page *page);
488 int file_load_page(struct file *file, unsigned long index, struct page **pp);
489
490 /* Process-related File management functions */
491 struct file *get_file_from_fd(struct files_struct *open_files, int fd);
492 struct file *put_file_from_fd(struct files_struct *open_files, int file_desc);
493 int insert_file(struct files_struct *open_files, struct file *file, int low_fd);
494 void close_all_files(struct files_struct *open_files, bool cloexec);
495 void clone_files(struct files_struct *src, struct files_struct *dst);
496 int do_chdir(struct fs_struct *fs_env, char *path);
497 char *do_getcwd(struct fs_struct *fs_env, char **kfree_this, size_t cwd_l);
498
499 /* Debugging */
500 int ls_dash_r(char *path);
501
502 #endif /* ROS_KERN_VFS_H */