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