HAMMER 13/many - Stabilization commit
[dragonfly.git] / sys / vfs / hammer / hammer_vfsops.c
1 /*
2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  * 
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  * 
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  * 
34  * $DragonFly: src/sys/vfs/hammer/hammer_vfsops.c,v 1.12 2007/12/31 05:33:12 dillon Exp $
35  */
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/vnode.h>
41 #include <sys/mount.h>
42 #include <sys/malloc.h>
43 #include <sys/nlookup.h>
44 #include <sys/fcntl.h>
45 #include <sys/sysctl.h>
46 #include <sys/buf.h>
47 #include <sys/buf2.h>
48 #include "hammer.h"
49
50 int hammer_debug_btree;
51 int hammer_count_inodes;
52 int hammer_count_records;
53 int hammer_count_record_datas;
54 int hammer_count_volumes;
55 int hammer_count_supercls;
56 int hammer_count_clusters;
57 int hammer_count_buffers;
58 int hammer_count_nodes;
59 int hammer_count_spikes;
60
61 SYSCTL_NODE(_vfs, OID_AUTO, hammer, CTLFLAG_RW, 0, "HAMMER filesystem");
62 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_btree, CTLFLAG_RW,
63            &hammer_debug_btree, 0, "");
64 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_inodes, CTLFLAG_RD,
65            &hammer_count_inodes, 0, "");
66 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_records, CTLFLAG_RD,
67            &hammer_count_records, 0, "");
68 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_record_datas, CTLFLAG_RD,
69            &hammer_count_record_datas, 0, "");
70 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_volumes, CTLFLAG_RD,
71            &hammer_count_volumes, 0, "");
72 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_supercls, CTLFLAG_RD,
73            &hammer_count_supercls, 0, "");
74 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_clusters, CTLFLAG_RD,
75            &hammer_count_clusters, 0, "");
76 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_buffers, CTLFLAG_RD,
77            &hammer_count_buffers, 0, "");
78 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_nodes, CTLFLAG_RD,
79            &hammer_count_nodes, 0, "");
80 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_spikes, CTLFLAG_RD,
81            &hammer_count_spikes, 0, "");
82
83 /*
84  * VFS ABI
85  */
86 static void     hammer_free_hmp(struct mount *mp);
87
88 static int      hammer_vfs_mount(struct mount *mp, char *path, caddr_t data,
89                                 struct ucred *cred);
90 static int      hammer_vfs_unmount(struct mount *mp, int mntflags);
91 static int      hammer_vfs_root(struct mount *mp, struct vnode **vpp);
92 static int      hammer_vfs_statfs(struct mount *mp, struct statfs *sbp,
93                                 struct ucred *cred);
94 static int      hammer_vfs_sync(struct mount *mp, int waitfor);
95 static int      hammer_vfs_init(struct vfsconf *conf);
96
97 static struct vfsops hammer_vfsops = {
98         .vfs_mount      = hammer_vfs_mount,
99         .vfs_unmount    = hammer_vfs_unmount,
100         .vfs_root       = hammer_vfs_root,
101         .vfs_statfs     = hammer_vfs_statfs,
102         .vfs_sync       = hammer_vfs_sync,
103         .vfs_vget       = hammer_vfs_vget,
104         .vfs_init       = hammer_vfs_init
105 };
106
107 MALLOC_DEFINE(M_HAMMER, "hammer-mount", "hammer mount");
108
109 VFS_SET(hammer_vfsops, hammer, 0);
110 MODULE_VERSION(hammer, 1);
111
112 static int
113 hammer_vfs_init(struct vfsconf *conf)
114 {
115         hammer_init_alist_config();
116         return(0);
117 }
118
119 static int
120 hammer_vfs_mount(struct mount *mp, char *mntpt, caddr_t data,
121                  struct ucred *cred)
122 {
123         struct hammer_mount_info info;
124         hammer_mount_t hmp;
125         hammer_volume_t rootvol;
126         struct vnode *rootvp;
127         const char *upath;      /* volume name in userspace */
128         char *path;             /* volume name in system space */
129         int error;
130         int i;
131
132         if ((error = copyin(data, &info, sizeof(info))) != 0)
133                 return (error);
134         if (info.nvolumes <= 0 || info.nvolumes >= 32768)
135                 return (EINVAL);
136
137         /*
138          * Interal mount data structure
139          */
140         if (mp->mnt_flag & MNT_UPDATE) {
141                 hmp = (void *)mp->mnt_data;
142                 KKASSERT(hmp != NULL);
143         } else {
144                 hmp = kmalloc(sizeof(*hmp), M_HAMMER, M_WAITOK | M_ZERO);
145                 mp->mnt_data = (qaddr_t)hmp;
146                 hmp->mp = mp;
147                 hmp->zbuf = kmalloc(HAMMER_BUFSIZE, M_HAMMER, M_WAITOK|M_ZERO);
148                 hmp->namekey_iterator = mycpu->gd_time_seconds;
149         }
150         hmp->hflags = info.hflags;
151         if (info.asof) {
152                 mp->mnt_flag |= MNT_RDONLY;
153                 hmp->asof = info.asof;
154         } else {
155                 hmp->asof = HAMMER_MAX_TID;
156         }
157
158         /*
159          * Re-open read-write if originally read-only, or vise-versa XXX
160          */
161         if (mp->mnt_flag & MNT_UPDATE) {
162                 if (hmp->ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
163                         kprintf("HAMMER read-write -> read-only XXX\n");
164                         hmp->ronly = 1;
165                 } else if (hmp->ronly && (mp->mnt_flag & MNT_RDONLY) == 0) {
166                         kprintf("HAMMER read-only -> read-write XXX\n");
167                         hmp->ronly = 0;
168                 }
169                 return(0);
170         }
171
172         RB_INIT(&hmp->rb_vols_root);
173         RB_INIT(&hmp->rb_inos_root);
174         hmp->ronly = ((mp->mnt_flag & MNT_RDONLY) != 0);
175
176         /*
177          * Load volumes
178          */
179         path = objcache_get(namei_oc, M_WAITOK);
180         hmp->nvolumes = info.nvolumes;
181         for (i = 0; i < info.nvolumes; ++i) {
182                 error = copyin(&info.volumes[i], &upath, sizeof(char *));
183                 if (error == 0)
184                         error = copyinstr(upath, path, MAXPATHLEN, NULL);
185                 if (error == 0)
186                         error = hammer_install_volume(hmp, path);
187                 if (error)
188                         break;
189         }
190         objcache_put(namei_oc, path);
191
192         /*
193          * Make sure we found a root volume
194          */
195         if (error == 0 && hmp->rootvol == NULL) {
196                 kprintf("hammer_mount: No root volume found!\n");
197                 error = EINVAL;
198         }
199         if (error == 0 && hmp->rootcl == NULL) {
200                 kprintf("hammer_mount: No root cluster found!\n");
201                 error = EINVAL;
202         }
203         if (error) {
204                 hammer_free_hmp(mp);
205                 return (error);
206         }
207
208         /*
209          * No errors, setup enough of the mount point so we can lookup the
210          * root vnode.
211          */
212         mp->mnt_iosize_max = MAXPHYS;
213         mp->mnt_kern_flag |= MNTK_FSMID;
214         mp->mnt_stat.f_fsid.val[0] = 0; /* XXX */
215         mp->mnt_stat.f_fsid.val[1] = 0; /* XXX */
216
217         /* 
218          * note: f_iosize is used by vnode_pager_haspage() when constructing
219          * its VOP_BMAP call.
220          */
221         mp->mnt_stat.f_iosize = HAMMER_BUFSIZE;
222         mp->mnt_stat.f_bsize = HAMMER_BUFSIZE;
223         vfs_getnewfsid(mp);             /* XXX */
224         mp->mnt_maxsymlinklen = 255;
225         mp->mnt_flag |= MNT_LOCAL;
226
227         vfs_add_vnodeops(mp, &hammer_vnode_vops, &mp->mnt_vn_norm_ops);
228         vfs_add_vnodeops(mp, &hammer_spec_vops, &mp->mnt_vn_spec_ops);
229         vfs_add_vnodeops(mp, &hammer_fifo_vops, &mp->mnt_vn_fifo_ops);
230
231         /*
232          * The root volume's ondisk pointer is only valid if we hold a
233          * reference to it.
234          */
235         rootvol = hammer_get_root_volume(hmp, &error);
236         if (error)
237                 goto done;
238         ksnprintf(mp->mnt_stat.f_mntfromname,
239                   sizeof(mp->mnt_stat.f_mntfromname), "%s",
240                   rootvol->ondisk->vol_name);
241         hammer_rel_volume(rootvol, 0);
242
243         /*
244          * Locate the root directory using the root cluster's B-Tree as a
245          * starting point.  The root directory uses an obj_id of 1.
246          *
247          * FUTURE: Leave the root directory cached referenced but unlocked
248          * in hmp->rootvp (need to flush it on unmount).
249          */
250         error = hammer_vfs_vget(mp, 1, &rootvp);
251         if (error)
252                 goto done;
253         vput(rootvp);
254         /*vn_unlock(hmp->rootvp);*/
255
256 done:
257         /*
258          * Cleanup and return.
259          */
260         if (error)
261                 hammer_free_hmp(mp);
262         return (error);
263 }
264
265 static int
266 hammer_vfs_unmount(struct mount *mp, int mntflags)
267 {
268 #if 0
269         struct hammer_mount *hmp = (void *)mp->mnt_data;
270 #endif
271         int flags;
272         int error;
273
274         /*
275          * Clean out the vnodes
276          */
277         flags = 0;
278         if (mntflags & MNT_FORCE)
279                 flags |= FORCECLOSE;
280         if ((error = vflush(mp, 0, flags)) != 0)
281                 return (error);
282
283         /*
284          * Clean up the internal mount structure and related entities.  This
285          * may issue I/O.
286          */
287         hammer_free_hmp(mp);
288         return(0);
289 }
290
291 /*
292  * Clean up the internal mount structure and disassociate it from the mount.
293  * This may issue I/O.
294  */
295 static void
296 hammer_free_hmp(struct mount *mp)
297 {
298         struct hammer_mount *hmp = (void *)mp->mnt_data;
299
300 #if 0
301         /*
302          * Clean up the root vnode
303          */
304         if (hmp->rootvp) {
305                 vrele(hmp->rootvp);
306                 hmp->rootvp = NULL;
307         }
308 #endif
309
310         /*
311          * Unload & flush inodes
312          */
313         RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
314                 hammer_unload_inode, NULL);
315
316         /*
317          * Unload & flush volumes
318          */
319         RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
320                 hammer_unload_volume, NULL);
321
322         mp->mnt_data = NULL;
323         mp->mnt_flag &= ~MNT_LOCAL;
324         hmp->mp = NULL;
325         kfree(hmp->zbuf, M_HAMMER);
326         kfree(hmp, M_HAMMER);
327 }
328
329 /*
330  * Return the root vnode for the filesystem.
331  *
332  * HAMMER stores the root vnode in the hammer_mount structure so
333  * getting it is easy.
334  */
335 static int
336 hammer_vfs_root(struct mount *mp, struct vnode **vpp)
337 {
338         struct hammer_mount *hmp = (void *)mp->mnt_data;
339         int error;
340
341         if (hmp->rootcl == NULL)
342                 error = EIO;
343         else
344                 error = hammer_vfs_vget(mp, 1, vpp);
345         return (error);
346 #if 0
347         /* FUTURE - cached root vnode */
348         if ((vp = hmp->rootvp) != NULL) {
349                 vref(vp);
350                 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
351                 *vpp = vp;
352                 return (0);
353         } else {
354                 *vpp = NULL;
355                 return (EIO);
356         }
357 #endif
358 }
359
360 static int
361 hammer_vfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
362 {
363         struct hammer_mount *hmp = (void *)mp->mnt_data;
364         hammer_volume_t volume;
365         hammer_volume_ondisk_t ondisk;
366         int error;
367
368         volume = hammer_get_root_volume(hmp, &error);
369         if (error)
370                 return(error);
371
372         ondisk = volume->ondisk;
373
374         mp->mnt_stat.f_bfree = mp->mnt_stat.f_blocks -
375                                 ondisk->vol0_stat_idx_bufs -
376                                 ondisk->vol0_stat_rec_bufs -
377                                 ondisk->vol0_stat_data_bufs;
378         if (mp->mnt_stat.f_bfree < 0)
379                 mp->mnt_stat.f_bfree = 0;
380         mp->mnt_stat.f_bavail = mp->mnt_stat.f_bfree;
381         mp->mnt_stat.f_files = ondisk->vol0_stat_inodes;
382         if (mp->mnt_stat.f_files < 0)
383                 mp->mnt_stat.f_files = 0;
384
385         hammer_rel_volume(volume, 0);
386         *sbp = mp->mnt_stat;
387         return(0);
388 }
389
390 static int
391 hammer_vfs_sync(struct mount *mp, int waitfor)
392 {
393         struct hammer_mount *hmp = (void *)mp->mnt_data;
394         int error;
395
396         error = hammer_sync_hmp(hmp, waitfor);
397         return(error);
398 }
399