tmpfs - Fix write-append/mmap-read race
[dragonfly.git] / sys / vfs / tmpfs / tmpfs.h
1 /*      $NetBSD: tmpfs.h,v 1.26 2007/02/22 06:37:00 thorpej Exp $       */
2
3 /*-
4  * Copyright (c) 2005, 2006 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
9  * 2005 program.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  *
32  * $FreeBSD: src/sys/fs/tmpfs/tmpfs.h,v 1.18 2009/10/11 07:03:56 delphij Exp $
33  */
34
35 #ifndef _VFS_TMPFS_TMPFS_H_
36 #define _VFS_TMPFS_TMPFS_H_
37
38 /* ---------------------------------------------------------------------
39  * KERNEL-SPECIFIC DEFINITIONS
40  * --------------------------------------------------------------------- */
41 #include <sys/dirent.h>
42 #include <sys/mount.h>
43 #include <sys/tree.h>
44 #include <sys/vnode.h>
45 #include <sys/file.h>
46 #include <sys/lock.h>
47 #include <sys/lockf.h>
48 #include <sys/mutex.h>
49 #include <sys/objcache.h>
50
51 /* --------------------------------------------------------------------- */
52 #include <sys/malloc.h>
53 #ifdef _KERNEL
54 #include <sys/systm.h>
55 #endif
56 #include <sys/vmmeter.h>
57 #include <vm/swap_pager.h>
58
59 MALLOC_DECLARE(M_TMPFSMNT);
60
61 /* --------------------------------------------------------------------- */
62
63 /*
64  * Internal representation of a tmpfs directory entry.
65  */
66 struct tmpfs_dirent {
67         RB_ENTRY(tmpfs_dirent)  rb_node;
68         RB_ENTRY(tmpfs_dirent)  rb_cookienode;
69
70         /* Length of the name stored in this directory entry.  This avoids
71          * the need to recalculate it every time the name is used. */
72         uint16_t                td_namelen;
73
74         /* The name of the entry, allocated from a string pool.  This
75         * string is not required to be zero-terminated; therefore, the
76         * td_namelen field must always be used when accessing its value. */
77         char                    *td_name;
78
79         /* Pointer to the node this entry refers to. */
80         struct tmpfs_node       *td_node;
81 };
82
83 struct tmpfs_dirtree;
84 RB_HEAD(tmpfs_dirtree, tmpfs_dirent);
85 RB_PROTOTYPE(tmpfs_dirtree, tmpfs_dirent, rb_node,
86         tmpfs_dirtree_compare);
87
88 RB_HEAD(tmpfs_dirtree_cookie, tmpfs_dirent);
89 RB_PROTOTYPE(tmpfs_dirtree_cookie, tmpfs_dirent, rb_cookienode,
90         tmpfs_dirtree_cookie_compare);
91
92
93 /*
94  * A directory in tmpfs holds a set of directory entries, which in
95  * turn point to other files (which can be directories themselves).
96  *
97  * In tmpfs, this set is managed by a red-black tree, whose root is defined
98  * by the struct tmpfs_dirtree type.
99  *
100  * It is important to notice that directories do not have entries for . and
101  * .. as other file systems do.  These can be generated when requested
102  * based on information available by other means, such as the pointer to
103  * the node itself in the former case or the pointer to the parent directory
104  * in the latter case.  This is done to simplify tmpfs's code and, more
105  * importantly, to remove redundancy.
106  *
107  * Each entry in a directory has a cookie that identifies it.  Cookies
108  * supersede offsets within directories because, given how tmpfs stores
109  * directories in memory, there is no such thing as an offset.  (Emulating
110  * a real offset could be very difficult.)
111  *
112  * The '.', '..' and the end of directory markers have fixed cookies which
113  * cannot collide with the cookies generated by other entries.  The cookies
114  * for the other entries are generated based on the memory address on which
115  * stores their information is stored.
116  *
117  * DragonFly binaries use 64-bit cookies.  We mask-off the signed bit to
118  * ensure that cookie 'offsets' are positive.
119  */
120 #ifdef _KERNEL
121
122 #define TMPFS_ROOTINO   ((ino_t)2)
123
124 #define TMPFS_DIRCOOKIE_DOT     0
125 #define TMPFS_DIRCOOKIE_DOTDOT  1
126 #define TMPFS_DIRCOOKIE_EOF     2
127
128 static __inline
129 off_t
130 tmpfs_dircookie(struct tmpfs_dirent *de)
131 {
132         return (((off_t)(uintptr_t)de >> 1) & 0x7FFFFFFFFFFFFFFFLLU);
133 }
134
135 #endif  /* _KERNEL */
136
137 /* --------------------------------------------------------------------- */
138
139 /*
140  * Internal representation of a tmpfs file system node.
141  *
142  * This structure is splitted in two parts: one holds attributes common
143  * to all file types and the other holds data that is only applicable to
144  * a particular type.  The code must be careful to only access those
145  * attributes that are actually allowed by the node's type.
146  */
147 struct tmpfs_node {
148         /* Doubly-linked list entry which links all existing nodes for a
149          * single file system.  This is provided to ease the removal of
150          * all nodes during the unmount operation. */
151         LIST_ENTRY(tmpfs_node)  tn_entries;
152
153         /* The node's type.  Any of 'VBLK', 'VCHR', 'VDIR', 'VFIFO',
154          * 'VLNK', 'VREG' and 'VSOCK' is allowed.  The usage of vnode
155          * types instead of a custom enumeration is to make things simpler
156          * and faster, as we do not need to convert between two types. */
157         enum vtype              tn_type;
158
159         /* Node identifier. */
160         ino_t                   tn_id;
161
162         /* Node's internal status.  This is used by several file system
163          * operations to do modifications to the node in a delayed
164          * fashion. */
165         int                     tn_status;
166 #define TMPFS_NODE_ACCESSED     (1 << 1)
167 #define TMPFS_NODE_MODIFIED     (1 << 2)
168 #define TMPFS_NODE_CHANGED      (1 << 3)
169
170         /* The node size.  It does not necessarily match the real amount
171          * of memory consumed by it. */
172         off_t                   tn_size;
173
174         /* Generic node attributes. */
175         uid_t                   tn_uid;
176         gid_t                   tn_gid;
177         mode_t                  tn_mode;
178         int                     tn_flags;
179         nlink_t                 tn_links;
180         int32_t                 tn_atime;
181         int32_t                 tn_atimensec;
182         int32_t                 tn_mtime;
183         int32_t                 tn_mtimensec;
184         int32_t                 tn_ctime;
185         int32_t                 tn_ctimensec;
186         unsigned long           tn_gen;
187         struct lockf            tn_advlock;
188
189         /* As there is a single vnode for each active file within the
190          * system, care has to be taken to avoid allocating more than one
191          * vnode per file.  In order to do this, a bidirectional association
192          * is kept between vnodes and nodes.
193          *
194          * Whenever a vnode is allocated, its v_data field is updated to
195          * point to the node it references.  At the same time, the node's
196          * tn_vnode field is modified to point to the new vnode representing
197          * it.  Further attempts to allocate a vnode for this same node will
198          * result in returning a new reference to the value stored in
199          * tn_vnode.
200          *
201          * May be NULL when the node is unused (that is, no vnode has been
202          * allocated for it or it has been reclaimed). */
203         struct vnode *          tn_vnode;
204
205         /* interlock to protect tn_vpstate */
206         struct lock             tn_interlock;
207
208         /* Identify if current node has vnode assiocate with
209          * or allocating vnode.
210          */
211         int             tn_vpstate;
212
213         /* misc data field for different tn_type node */
214         union {
215                 /* Valid when tn_type == VBLK || tn_type == VCHR. */
216                 dev_t                   tn_rdev; /*int32_t ?*/
217
218                 /* Valid when tn_type == VDIR. */
219                 struct tn_dir {
220                         /*
221                          * Pointer to the parent directory.  The root
222                          * directory has a pointer to itself in this field;
223                          * this property identifies the root node.
224                          */
225                         struct tmpfs_node *     tn_parent;
226
227                         /*
228                          * Directory entries are indexed by name and also
229                          * indexed by cookie.
230                          */
231                         struct tmpfs_dirtree            tn_dirtree;
232                         struct tmpfs_dirtree_cookie     tn_cookietree;
233                 } tn_dir;
234
235                 /* Valid when tn_type == VLNK. */
236                 /* The link's target, allocated from a string pool. */
237                 char *                  tn_link;
238
239                 /* Valid when tn_type == VREG. */
240                 struct tn_reg {
241                         /* The contents of regular files stored in a tmpfs
242                          * file system are represented by a single anonymous
243                          * memory object (aobj, for short).  The aobj provides
244                          * direct access to any position within the file,
245                          * because its contents are always mapped in a
246                          * contiguous region of virtual memory.  It is a task
247                          * of the memory management subsystem (see uvm(9)) to
248                          * issue the required page ins or page outs whenever
249                          * a position within the file is accessed. */
250                         vm_object_t             tn_aobj;
251                         size_t                  tn_aobj_pages;
252
253                 } tn_reg;
254
255                 /* Valid when tn_type = VFIFO */
256                 struct tn_fifo {
257                         int (*tn_fo_read)  (struct file *fp, struct uio *uio,
258                                 struct ucred *cred, int flags);
259                         int (*tn_fo_write) (struct file *fp, struct uio *uio,
260                                 struct ucred *cred, int flags);
261                 } tn_fifo;
262         } tn_spec;
263 };
264
265 /* Only userspace needs this */
266 #define VTOI(vp)        ((struct tmpfs_node *)(vp)->v_data)
267
268 #ifdef _KERNEL
269 LIST_HEAD(tmpfs_node_list, tmpfs_node);
270
271 #define tn_rdev tn_spec.tn_rdev
272 #define tn_dir tn_spec.tn_dir
273 #define tn_link tn_spec.tn_link
274 #define tn_reg tn_spec.tn_reg
275 #define tn_fifo tn_spec.tn_fifo
276
277 #define TMPFS_NODE_LOCK(node) lockmgr(&(node)->tn_interlock, LK_EXCLUSIVE|LK_RETRY)
278 #define TMPFS_NODE_LOCK_SH(node) lockmgr(&(node)->tn_interlock, LK_SHARED|LK_RETRY)
279 #define TMPFS_NODE_UNLOCK(node) lockmgr(&(node)->tn_interlock, LK_RELEASE)
280 #define TMPFS_NODE_MTX(node) (&(node)->tn_interlock)
281
282 #ifdef INVARIANTS
283 #define TMPFS_ASSERT_LOCKED(node) do {                                  \
284                 KKASSERT(node != NULL);                                 \
285                 KKASSERT(node->tn_vnode != NULL);                       \
286                 if (!vn_islocked(node->tn_vnode) &&                     \
287                     (lockstatus(TMPFS_NODE_MTX(node), curthread) == LK_EXCLUSIVE ))             \
288                         panic("tmpfs: node is not locked: %p", node);   \
289         } while (0)
290 #define TMPFS_ASSERT_ELOCKED(node) do {                                 \
291                 KKASSERT((node) != NULL);                               \
292                 KKASSERT(lockstatus(TMPFS_NODE_MTX(node), curthread) == LK_EXCLUSIVE);          \
293         } while (0)
294 #else
295 #define TMPFS_ASSERT_LOCKED(node) (void)0
296 #define TMPFS_ASSERT_ELOCKED(node) (void)0
297 #endif  /* INVARIANTS */
298
299 #define TMPFS_VNODE_ALLOCATING  1
300 #define TMPFS_VNODE_WANT        2
301 #define TMPFS_VNODE_DOOMED      4
302 /* --------------------------------------------------------------------- */
303
304 /*
305  * Internal representation of a tmpfs mount point.
306  */
307 struct tmpfs_mount {
308         struct mount            *tm_mount;
309
310         /* Maximum number of memory pages available for use by the file
311          * system, set during mount time.  This variable must never be
312          * used directly as it may be bigger than the current amount of
313          * free memory; in the extreme case, it will hold the SIZE_MAX
314          * value.  Instead, use the TMPFS_PAGES_MAX macro. */
315         long                    tm_pages_max;
316
317         /* Number of pages in use by the file system.  Cannot be bigger
318          * than the value returned by TMPFS_PAGES_MAX in any case. */
319         long                    tm_pages_used;
320
321         /* Pointer to the node representing the root directory of this
322          * file system. */
323         struct tmpfs_node *     tm_root;
324
325         /* Maximum number of possible nodes for this file system; set
326          * during mount time.  We need a hard limit on the maximum number
327          * of nodes to avoid allocating too much of them; their objects
328          * cannot be released until the file system is unmounted.
329          * Otherwise, we could easily run out of memory by creating lots
330          * of empty files and then simply removing them. */
331         ino_t                   tm_nodes_max;
332
333         /* Number of nodes currently that are in use. */
334         ino_t                   tm_nodes_inuse;
335
336         /* maximum representable file size */
337         u_int64_t               tm_maxfilesize;
338
339         /* Nodes are organized in two different lists.  The used list
340          * contains all nodes that are currently used by the file system;
341          * i.e., they refer to existing files.  The available list contains
342          * all nodes that are currently available for use by new files.
343          * Nodes must be kept in this list (instead of deleting them)
344          * because we need to keep track of their generation number (tn_gen
345          * field).
346          *
347          * Note that nodes are lazily allocated: if the available list is
348          * empty and we have enough space to create more nodes, they will be
349          * created and inserted in the used list.  Once these are released,
350          * they will go into the available list, remaining alive until the
351          * file system is unmounted. */
352         struct tmpfs_node_list  tm_nodes_used;
353
354         /* Per-mount malloc zones for tmpfs nodes, names, and dirents */
355         struct malloc_type      *tm_node_zone;
356         struct malloc_type      *tm_dirent_zone;
357         struct malloc_type      *tm_name_zone;
358
359         struct objcache_malloc_args tm_node_zone_malloc_args;
360         struct objcache_malloc_args tm_dirent_zone_malloc_args;
361
362         /* Pools used to store file system meta data. */
363         struct objcache         *tm_dirent_pool;
364         struct objcache         *tm_node_pool;
365
366         ino_t                   tm_ino;
367         int                     tm_flags;
368
369         struct netexport        tm_export;
370
371         struct mount            *tm_mnt;
372 };
373
374 #define TMPFS_LOCK(tm) lwkt_gettoken(&(tm)->tm_mount->mnt_token)
375 #define TMPFS_UNLOCK(tm) lwkt_reltoken(&(tm)->tm_mount->mnt_token)
376
377 /* --------------------------------------------------------------------- */
378
379 /*
380  * This structure maps a file identifier to a tmpfs node.  Used by the
381  * NFS code.
382  */
383 struct tmpfs_fid {
384         uint16_t                tf_len;
385         uint16_t                tf_pad;
386         ino_t                   tf_id;
387         unsigned long           tf_gen;
388 };
389
390 /* --------------------------------------------------------------------- */
391
392 /*
393  * Prototypes for tmpfs_subr.c.
394  */
395
396 int     tmpfs_alloc_node(struct tmpfs_mount *, enum vtype,
397             uid_t uid, gid_t gid, mode_t mode, char *, int, int,
398             struct tmpfs_node **);
399 void    tmpfs_free_node(struct tmpfs_mount *, struct tmpfs_node *);
400 int     tmpfs_alloc_dirent(struct tmpfs_mount *, struct tmpfs_node *,
401             const char *, uint16_t, struct tmpfs_dirent **);
402 void    tmpfs_free_dirent(struct tmpfs_mount *, struct tmpfs_dirent *);
403 int     tmpfs_alloc_vp(struct mount *, struct tmpfs_node *, int,
404             struct vnode **);
405 void    tmpfs_free_vp(struct vnode *);
406 int     tmpfs_alloc_file(struct vnode *, struct vnode **, struct vattr *,
407             struct namecache *, struct ucred *, char *);
408 void    tmpfs_dir_attach(struct tmpfs_node *, struct tmpfs_dirent *);
409 void    tmpfs_dir_detach(struct tmpfs_node *, struct tmpfs_dirent *);
410 struct tmpfs_dirent *   tmpfs_dir_lookup(struct tmpfs_node *node,
411                             struct tmpfs_node *f,
412                             struct namecache *ncp);
413 int     tmpfs_dir_getdotdent(struct tmpfs_node *, struct uio *);
414 int     tmpfs_dir_getdotdotdent(struct tmpfs_mount *,
415                             struct tmpfs_node *, struct uio *);
416 struct tmpfs_dirent *   tmpfs_dir_lookupbycookie(struct tmpfs_node *, off_t);
417 int     tmpfs_dir_getdents(struct tmpfs_node *, struct uio *, off_t *);
418 int     tmpfs_reg_resize(struct vnode *, off_t, int);
419 int     tmpfs_chflags(struct vnode *, int, struct ucred *);
420 int     tmpfs_chmod(struct vnode *, mode_t, struct ucred *);
421 int     tmpfs_chown(struct vnode *, uid_t, gid_t, struct ucred *);
422 int     tmpfs_chsize(struct vnode *, u_quad_t, struct ucred *);
423 int     tmpfs_chtimes(struct vnode *, struct timespec *, struct timespec *,
424             int, struct ucred *);
425 void    tmpfs_itimes(struct vnode *, const struct timespec *,
426             const struct timespec *);
427
428 void    tmpfs_update(struct vnode *);
429 int     tmpfs_truncate(struct vnode *, off_t);
430 boolean_t tmpfs_node_ctor(void *obj, void *privdata, int flags);
431
432 /* --------------------------------------------------------------------- */
433
434 /*
435  * Convenience macros to simplify some logical expressions.
436  */
437 #define IMPLIES(a, b) (!(a) || (b))
438 #define IFF(a, b) (IMPLIES(a, b) && IMPLIES(b, a))
439
440 /* --------------------------------------------------------------------- */
441
442 /*
443  * Checks that the directory entry pointed by 'de' matches the name 'name'
444  * with a length of 'len'.
445  */
446 #define TMPFS_DIRENT_MATCHES(de, name, len) \
447     (de->td_namelen == (uint16_t)len && \
448     bcmp((de)->td_name, (name), (de)->td_namelen) == 0)
449
450 /* --------------------------------------------------------------------- */
451
452 /*
453  * Ensures that the node pointed by 'node' is a directory and that its
454  * contents are consistent with respect to directories.
455  */
456 #define TMPFS_VALIDATE_DIR(node) do {   \
457     KKASSERT((node)->tn_type == VDIR);  \
458     KKASSERT((node)->tn_size % sizeof(struct tmpfs_dirent) == 0); \
459 } while(0)
460
461 /* --------------------------------------------------------------------- */
462
463 /*
464  * Macros/functions to convert from generic data structures to tmpfs
465  * specific ones.  Kernel code use VP_TO_TMPFS_NODE() instead of VTOI().
466  */
467
468 static inline
469 struct tmpfs_mount *
470 VFS_TO_TMPFS(struct mount *mp)
471 {
472         struct tmpfs_mount *tmp;
473
474         KKASSERT((mp) != NULL && (mp)->mnt_data != NULL);
475         tmp = (struct tmpfs_mount *)(mp)->mnt_data;
476         return tmp;
477 }
478
479 static inline
480 struct tmpfs_node *
481 VP_TO_TMPFS_NODE(struct vnode *vp)
482 {
483         struct tmpfs_node *node;
484
485         KKASSERT((vp) != NULL && (vp)->v_data != NULL);
486         node = (struct tmpfs_node *)vp->v_data;
487         return node;
488 }
489
490 static inline
491 struct tmpfs_node *
492 VP_TO_TMPFS_DIR(struct vnode *vp)
493 {
494         struct tmpfs_node *node;
495
496         node = VP_TO_TMPFS_NODE(vp);
497         TMPFS_VALIDATE_DIR(node);
498         return node;
499 }
500
501 /* --------------------------------------------------------------------- */
502 /*
503  * buffer cache size
504  */
505 #define TMPFS_BLKSIZE   16384                   /* buffer cache size*/
506 #define TMPFS_BLKMASK   (TMPFS_BLKSIZE - 1)
507 #define TMPFS_BLKMASK64 ((off_t)(TMPFS_BLKSIZE - 1))
508 #endif /* _KERNEL */
509
510 #endif /* _VFS_TMPFS_TMPFS_H_ */