7e8a7e68a9293881e3337488bbf8032035de97b5
[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/queue.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 #include <sys/systm.h>
54 #include <sys/vmmeter.h>
55 #include <vm/swap_pager.h>
56
57 MALLOC_DECLARE(M_TMPFSMNT);
58
59 /* --------------------------------------------------------------------- */
60
61 /*
62  * Internal representation of a tmpfs directory entry.
63  */
64 struct tmpfs_dirent {
65         TAILQ_ENTRY(tmpfs_dirent)       td_entries;
66
67         /* Length of the name stored in this directory entry.  This avoids
68          * the need to recalculate it every time the name is used. */
69         uint16_t                        td_namelen;
70
71         /* The name of the entry, allocated from a string pool.  This
72         * string is not required to be zero-terminated; therefore, the
73         * td_namelen field must always be used when accessing its value. */
74         char *                          td_name;
75
76         /* Pointer to the node this entry refers to. */
77         struct tmpfs_node *             td_node;
78 };
79
80 /* A directory in tmpfs holds a sorted list of directory entries, which in
81  * turn point to other files (which can be directories themselves).
82  *
83  * In tmpfs, this list is managed by a tail queue, whose head is defined by
84  * the struct tmpfs_dir type.
85  *
86  * It is imporant to notice that directories do not have entries for . and
87  * .. as other file systems do.  These can be generated when requested
88  * based on information available by other means, such as the pointer to
89  * the node itself in the former case or the pointer to the parent directory
90  * in the latter case.  This is done to simplify tmpfs's code and, more
91  * importantly, to remove redundancy. */
92 TAILQ_HEAD(tmpfs_dir, tmpfs_dirent);
93
94 /* Each entry in a directory has a cookie that identifies it.  Cookies
95  * supersede offsets within directories because, given how tmpfs stores
96  * directories in memory, there is no such thing as an offset.  (Emulating
97  * a real offset could be very difficult.)
98  *
99  * The '.', '..' and the end of directory markers have fixed cookies which
100  * cannot collide with the cookies generated by other entries.  The cookies
101  * for the other entries are generated based on the memory address on which
102  * stores their information is stored.
103  *
104  * Ideally, using the entry's memory pointer as the cookie would be enough
105  * to represent it and it wouldn't cause collisions in any system.
106  * Unfortunately, this results in "offsets" with very large values which
107  * later raise problems in the Linux compatibility layer (and maybe in other
108  * places) as described in PR kern/32034.  Hence we need to workaround this
109  * with a rather ugly hack.
110  *
111  * Linux 32-bit binaries, unless built with _FILE_OFFSET_BITS=64, have off_t
112  * set to 'long', which is a 32-bit *signed* long integer.  Regardless of
113  * the macro value, GLIBC (2.3 at least) always uses the getdents64
114  * system call (when calling readdir) which internally returns off64_t
115  * offsets.  In order to make 32-bit binaries work, *GLIBC* converts the
116  * 64-bit values returned by the kernel to 32-bit ones and aborts with
117  * EOVERFLOW if the conversion results in values that won't fit in 32-bit
118  * integers (which it assumes is because the directory is extremely large).
119  * This wouldn't cause problems if we were dealing with unsigned integers,
120  * but as we have signed integers, this check fails due to sign expansion.
121  *
122  * For example, consider that the kernel returns the 0xc1234567 cookie to
123  * userspace in a off64_t integer.  Later on, GLIBC casts this value to
124  * off_t (remember, signed) with code similar to:
125  *     system call returns the offset in kernel_value;
126  *     off_t casted_value = kernel_value;
127  *     if (sizeof(off_t) != sizeof(off64_t) &&
128  *         kernel_value != casted_value)
129  *             error!
130  * In this case, casted_value still has 0xc1234567, but when it is compared
131  * for equality against kernel_value, it is promoted to a 64-bit integer and
132  * becomes 0xffffffffc1234567, which is different than 0x00000000c1234567.
133  * Then, GLIBC assumes this is because the directory is very large.
134  *
135  * Given that all the above happens in user-space, we have no control over
136  * it; therefore we must workaround the issue here.  We do this by
137  * truncating the pointer value to a 32-bit integer and hope that there
138  * won't be collisions.  In fact, this will not cause any problems in
139  * 32-bit platforms but some might arise in 64-bit machines (I'm not sure
140  * if they can happen at all in practice).
141  *
142  * XXX A nicer solution shall be attempted. */
143 #ifdef _KERNEL
144 #define TMPFS_DIRCOOKIE_DOT     0
145 #define TMPFS_DIRCOOKIE_DOTDOT  1
146 #define TMPFS_DIRCOOKIE_EOF     2
147 static __inline
148 off_t
149 tmpfs_dircookie(struct tmpfs_dirent *de)
150 {
151         off_t cookie;
152
153         cookie = ((off_t)(uintptr_t)de >> 1) & 0x7FFFFFFF;
154         KKASSERT(cookie != TMPFS_DIRCOOKIE_DOT);
155         KKASSERT(cookie != TMPFS_DIRCOOKIE_DOTDOT);
156         KKASSERT(cookie != TMPFS_DIRCOOKIE_EOF);
157
158         return cookie;
159 }
160 #endif
161
162 /* --------------------------------------------------------------------- */
163
164 /*
165  * Internal representation of a tmpfs file system node.
166  *
167  * This structure is splitted in two parts: one holds attributes common
168  * to all file types and the other holds data that is only applicable to
169  * a particular type.  The code must be careful to only access those
170  * attributes that are actually allowed by the node's type.
171  *
172  *
173  * Below is the key of locks used to protected the fields in the following
174  * structures.
175  *
176  */
177 struct tmpfs_node {
178         /* Doubly-linked list entry which links all existing nodes for a
179          * single file system.  This is provided to ease the removal of
180          * all nodes during the unmount operation. */
181         LIST_ENTRY(tmpfs_node)  tn_entries;
182
183         /* The node's type.  Any of 'VBLK', 'VCHR', 'VDIR', 'VFIFO',
184          * 'VLNK', 'VREG' and 'VSOCK' is allowed.  The usage of vnode
185          * types instead of a custom enumeration is to make things simpler
186          * and faster, as we do not need to convert between two types. */
187         enum vtype              tn_type;
188
189         /* Node identifier. */
190         ino_t                   tn_id;
191
192         /* Node's internal status.  This is used by several file system
193          * operations to do modifications to the node in a delayed
194          * fashion. */
195         int                     tn_status;
196 #define TMPFS_NODE_ACCESSED     (1 << 1)
197 #define TMPFS_NODE_MODIFIED     (1 << 2)
198 #define TMPFS_NODE_CHANGED      (1 << 3)
199
200         /* The node size.  It does not necessarily match the real amount
201          * of memory consumed by it. */
202         off_t                   tn_size;
203
204         /* Generic node attributes. */
205         uid_t                   tn_uid;
206         gid_t                   tn_gid;
207         mode_t                  tn_mode;
208         int                     tn_flags;
209         nlink_t                 tn_links;
210         int32_t                 tn_atime;
211         int32_t                 tn_atimensec;
212         int32_t                 tn_mtime;
213         int32_t                 tn_mtimensec;
214         int32_t                 tn_ctime;
215         int32_t                 tn_ctimensec;
216         unsigned long           tn_gen;
217         struct lockf            tn_advlock;
218
219         /* As there is a single vnode for each active file within the
220          * system, care has to be taken to avoid allocating more than one
221          * vnode per file.  In order to do this, a bidirectional association
222          * is kept between vnodes and nodes.
223          *
224          * Whenever a vnode is allocated, its v_data field is updated to
225          * point to the node it references.  At the same time, the node's
226          * tn_vnode field is modified to point to the new vnode representing
227          * it.  Further attempts to allocate a vnode for this same node will
228          * result in returning a new reference to the value stored in
229          * tn_vnode.
230          *
231          * May be NULL when the node is unused (that is, no vnode has been
232          * allocated for it or it has been reclaimed). */
233         struct vnode *          tn_vnode;
234
235         /* interlock to protect tn_vpstate */
236         struct lock             tn_interlock;
237
238         /* Identify if current node has vnode assiocate with
239          * or allocating vnode.
240          */
241         int             tn_vpstate;
242
243         /* misc data field for different tn_type node */
244         union {
245                 /* Valid when tn_type == VBLK || tn_type == VCHR. */
246                 dev_t                   tn_rdev; /*int32_t ?*/
247
248                 /* Valid when tn_type == VDIR. */
249                 struct tn_dir{
250                         /* Pointer to the parent directory.  The root
251                          * directory has a pointer to itself in this field;
252                          * this property identifies the root node. */
253                         struct tmpfs_node *     tn_parent;
254
255                         /* Head of a tail-queue that links the contents of
256                          * the directory together.  See above for a
257                          * description of its contents. */
258                         struct tmpfs_dir        tn_dirhead;
259
260                         /* Number and pointer of the first directory entry
261                          * returned by the readdir operation if it were
262                          * called again to continue reading data from the
263                          * same directory as before.  This is used to speed
264                          * up reads of long directories, assuming that no
265                          * more than one read is in progress at a given time.
266                          * Otherwise, these values are discarded and a linear
267                          * scan is performed from the beginning up to the
268                          * point where readdir starts returning values. */
269                         off_t                   tn_readdir_lastn;
270                         struct tmpfs_dirent *   tn_readdir_lastp;
271                 }tn_dir;
272
273                 /* Valid when tn_type == VLNK. */
274                 /* The link's target, allocated from a string pool. */
275                 char *                  tn_link;
276
277                 /* Valid when tn_type == VREG. */
278                 struct tn_reg {
279                         /* The contents of regular files stored in a tmpfs
280                          * file system are represented by a single anonymous
281                          * memory object (aobj, for short).  The aobj provides
282                          * direct access to any position within the file,
283                          * because its contents are always mapped in a
284                          * contiguous region of virtual memory.  It is a task
285                          * of the memory management subsystem (see uvm(9)) to
286                          * issue the required page ins or page outs whenever
287                          * a position within the file is accessed. */
288                         vm_object_t             tn_aobj;
289                         size_t                  tn_aobj_pages;
290
291                 }tn_reg;
292
293                 /* Valid when tn_type = VFIFO */
294                 struct tn_fifo {
295                         int (*tn_fo_read)  (struct file *fp, struct uio *uio,
296                                 struct ucred *cred, int flags);
297                         int (*tn_fo_write) (struct file *fp, struct uio *uio,
298                                 struct ucred *cred, int flags);
299                 }tn_fifo;
300         }tn_spec;
301 };
302 LIST_HEAD(tmpfs_node_list, tmpfs_node);
303
304 #define tn_rdev tn_spec.tn_rdev
305 #define tn_dir tn_spec.tn_dir
306 #define tn_link tn_spec.tn_link
307 #define tn_reg tn_spec.tn_reg
308 #define tn_fifo tn_spec.tn_fifo
309
310 #define TMPFS_NODE_LOCK(node) lockmgr(&(node)->tn_interlock, LK_EXCLUSIVE|LK_RETRY)
311 #define TMPFS_NODE_UNLOCK(node) lockmgr(&(node)->tn_interlock, LK_RELEASE)
312 #define TMPFS_NODE_MTX(node) (&(node)->tn_interlock)
313
314 #ifdef INVARIANTS
315 #define TMPFS_ASSERT_LOCKED(node) do {                                  \
316                 KKASSERT(node != NULL);                                 \
317                 KKASSERT(node->tn_vnode != NULL);                       \
318                 if (!vn_islocked(node->tn_vnode) &&                     \
319                     (lockstatus(TMPFS_NODE_MTX(node), curthread) == LK_EXCLUSIVE ))             \
320                         panic("tmpfs: node is not locked: %p", node);   \
321         } while (0)
322 #define TMPFS_ASSERT_ELOCKED(node) do {                                 \
323                 KKASSERT((node) != NULL);                               \
324                 KKASSERT(lockstatus(TMPFS_NODE_MTX(node), curthread) == LK_EXCLUSIVE);          \
325         } while (0)
326 #else
327 #define TMPFS_ASSERT_LOCKED(node) (void)0
328 #define TMPFS_ASSERT_ELOCKED(node) (void)0
329 #endif
330
331 #define TMPFS_VNODE_ALLOCATING  1
332 #define TMPFS_VNODE_WANT        2
333 #define TMPFS_VNODE_DOOMED      4
334 /* --------------------------------------------------------------------- */
335
336 /*
337  * Internal representation of a tmpfs mount point.
338  */
339 struct tmpfs_mount {
340         /* Maximum number of memory pages available for use by the file
341          * system, set during mount time.  This variable must never be
342          * used directly as it may be bigger than the current amount of
343          * free memory; in the extreme case, it will hold the SIZE_MAX
344          * value.  Instead, use the TMPFS_PAGES_MAX macro. */
345         vm_pindex_t             tm_pages_max;
346
347         /* Number of pages in use by the file system.  Cannot be bigger
348          * than the value returned by TMPFS_PAGES_MAX in any case. */
349         vm_pindex_t             tm_pages_used;
350
351         /* Pointer to the node representing the root directory of this
352          * file system. */
353         struct tmpfs_node *     tm_root;
354
355         /* Maximum number of possible nodes for this file system; set
356          * during mount time.  We need a hard limit on the maximum number
357          * of nodes to avoid allocating too much of them; their objects
358          * cannot be released until the file system is unmounted.
359          * Otherwise, we could easily run out of memory by creating lots
360          * of empty files and then simply removing them. */
361         ino_t                   tm_nodes_max;
362
363         /* Number of nodes currently that are in use. */
364         ino_t                   tm_nodes_inuse;
365
366         /* maximum representable file size */
367         u_int64_t               tm_maxfilesize;
368
369         /* Nodes are organized in two different lists.  The used list
370          * contains all nodes that are currently used by the file system;
371          * i.e., they refer to existing files.  The available list contains
372          * all nodes that are currently available for use by new files.
373          * Nodes must be kept in this list (instead of deleting them)
374          * because we need to keep track of their generation number (tn_gen
375          * field).
376          *
377          * Note that nodes are lazily allocated: if the available list is
378          * empty and we have enough space to create more nodes, they will be
379          * created and inserted in the used list.  Once these are released,
380          * they will go into the available list, remaining alive until the
381          * file system is unmounted. */
382         struct tmpfs_node_list  tm_nodes_used;
383
384         /* All node lock to protect the node list and tmp_pages_used */
385         struct lock              allnode_lock;
386
387         /* Per-mount malloc zones for tmpfs nodes, names, and dirents */
388         struct malloc_type      *tm_node_zone;
389         struct malloc_type      *tm_dirent_zone;
390         struct malloc_type      *tm_name_zone;
391
392         struct objcache_malloc_args tm_node_zone_malloc_args;
393         struct objcache_malloc_args tm_dirent_zone_malloc_args;
394
395         /* Pools used to store file system meta data.  These are not shared
396          * across several instances of tmpfs for the reasons described in
397          * tmpfs_pool.c. */
398         struct objcache         *tm_dirent_pool;
399         struct objcache         *tm_node_pool;
400
401         int                     tm_ino;
402         int                     tm_flags;
403
404         struct netexport        tm_export;
405 };
406
407 #define TMPFS_LOCK(tm) lockmgr(&(tm)->allnode_lock, LK_EXCLUSIVE|LK_RETRY)
408 #define TMPFS_UNLOCK(tm) lockmgr(&(tm)->allnode_lock, LK_RELEASE)
409
410 /* --------------------------------------------------------------------- */
411
412 /*
413  * This structure maps a file identifier to a tmpfs node.  Used by the
414  * NFS code.
415  */
416 struct tmpfs_fid {
417         uint16_t                tf_len;
418         uint16_t                tf_pad;
419         ino_t                   tf_id;
420         unsigned long           tf_gen;
421 };
422
423 /* --------------------------------------------------------------------- */
424
425 #ifdef _KERNEL
426 /*
427  * Prototypes for tmpfs_subr.c.
428  */
429
430 int     tmpfs_alloc_node(struct tmpfs_mount *, enum vtype,
431             uid_t uid, gid_t gid, mode_t mode, struct tmpfs_node *,
432             char *, int, int, struct tmpfs_node **);
433 void    tmpfs_free_node(struct tmpfs_mount *, struct tmpfs_node *);
434 int     tmpfs_alloc_dirent(struct tmpfs_mount *, struct tmpfs_node *,
435             const char *, uint16_t, struct tmpfs_dirent **);
436 void    tmpfs_free_dirent(struct tmpfs_mount *, struct tmpfs_dirent *);
437 int     tmpfs_alloc_vp(struct mount *, struct tmpfs_node *, int,
438             struct vnode **);
439 void    tmpfs_free_vp(struct vnode *);
440 int     tmpfs_alloc_file(struct vnode *, struct vnode **, struct vattr *,
441             struct namecache *, struct ucred *, char *);
442 void    tmpfs_dir_attach(struct tmpfs_node *, struct tmpfs_dirent *);
443 void    tmpfs_dir_detach(struct tmpfs_node *, struct tmpfs_dirent *);
444 struct tmpfs_dirent *   tmpfs_dir_lookup(struct tmpfs_node *node,
445                             struct tmpfs_node *f,
446                             struct namecache *ncp);
447 int     tmpfs_dir_getdotdent(struct tmpfs_node *, struct uio *);
448 int     tmpfs_dir_getdotdotdent(struct tmpfs_mount *,
449                             struct tmpfs_node *, struct uio *);
450 struct tmpfs_dirent *   tmpfs_dir_lookupbycookie(struct tmpfs_node *, off_t);
451 int     tmpfs_dir_getdents(struct tmpfs_node *, struct uio *, off_t *);
452 int     tmpfs_reg_resize(struct vnode *, off_t, int);
453 int     tmpfs_chflags(struct vnode *, int, struct ucred *);
454 int     tmpfs_chmod(struct vnode *, mode_t, struct ucred *);
455 int     tmpfs_chown(struct vnode *, uid_t, gid_t, struct ucred *);
456 int     tmpfs_chsize(struct vnode *, u_quad_t, struct ucred *);
457 int     tmpfs_chtimes(struct vnode *, struct timespec *, struct timespec *,
458             int, struct ucred *);
459 void    tmpfs_itimes(struct vnode *, const struct timespec *,
460             const struct timespec *);
461
462 void    tmpfs_update(struct vnode *);
463 int     tmpfs_truncate(struct vnode *, off_t);
464 int     tmpfs_node_ctor(void *obj, void *privdata, int flags);
465
466 /* --------------------------------------------------------------------- */
467
468 /*
469  * Convenience macros to simplify some logical expressions.
470  */
471 #define IMPLIES(a, b) (!(a) || (b))
472 #define IFF(a, b) (IMPLIES(a, b) && IMPLIES(b, a))
473
474 /* --------------------------------------------------------------------- */
475
476 /*
477  * Checks that the directory entry pointed by 'de' matches the name 'name'
478  * with a length of 'len'.
479  */
480 #define TMPFS_DIRENT_MATCHES(de, name, len) \
481     (de->td_namelen == (uint16_t)len && \
482     bcmp((de)->td_name, (name), (de)->td_namelen) == 0)
483
484 /* --------------------------------------------------------------------- */
485
486 /*
487  * Ensures that the node pointed by 'node' is a directory and that its
488  * contents are consistent with respect to directories.
489  */
490 #define TMPFS_VALIDATE_DIR(node) \
491     KKASSERT((node)->tn_type == VDIR); \
492     KKASSERT((node)->tn_size % sizeof(struct tmpfs_dirent) == 0); \
493     KKASSERT((node)->tn_dir.tn_readdir_lastp == NULL || \
494         tmpfs_dircookie((node)->tn_dir.tn_readdir_lastp) == (node)->tn_dir.tn_readdir_lastn);
495
496 #endif
497
498 /* --------------------------------------------------------------------- */
499
500 /*
501  * Macros/functions to convert from generic data structures to tmpfs
502  * specific ones.
503  */
504
505 static inline
506 struct tmpfs_mount *
507 VFS_TO_TMPFS(struct mount *mp)
508 {
509         struct tmpfs_mount *tmp;
510
511         KKASSERT((mp) != NULL && (mp)->mnt_data != NULL);
512         tmp = (struct tmpfs_mount *)(mp)->mnt_data;
513         return tmp;
514 }
515
516 static inline
517 struct tmpfs_node *
518 VP_TO_TMPFS_NODE(struct vnode *vp)
519 {
520         struct tmpfs_node *node;
521
522         KKASSERT((vp) != NULL && (vp)->v_data != NULL);
523         node = (struct tmpfs_node *)vp->v_data;
524         return node;
525 }
526
527 static inline
528 struct tmpfs_node *
529 VP_TO_TMPFS_DIR(struct vnode *vp)
530 {
531         struct tmpfs_node *node;
532
533         node = VP_TO_TMPFS_NODE(vp);
534         TMPFS_VALIDATE_DIR(node);
535         return node;
536 }
537
538 /* --------------------------------------------------------------------- */
539 /*
540  * buffer cache size
541  */
542 #define BSIZE (off_t)16384          /* buffer cache size*/
543 #define BMASK (off_t)(BSIZE - 1)
544
545 #endif /* _VFS_TMPFS_TMPFS_H_ */