674ec2ee8be2e2ecbf6c51810c046b01a9697055
[dragonfly.git] / sys / vfs / hammer / hammer_vfsops.c
1 /*
2  * Copyright (c) 2007-2008 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.74 2008/11/13 02:18:43 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_supported_version = HAMMER_VOL_VERSION_DEFAULT;
51 int hammer_debug_io;
52 int hammer_debug_general;
53 int hammer_debug_debug = 1;             /* medium-error panics */ 
54 int hammer_debug_inode;
55 int hammer_debug_locks;
56 int hammer_debug_btree;
57 int hammer_debug_tid;
58 int hammer_debug_recover;               /* -1 will disable, +1 will force */
59 int hammer_debug_recover_faults;
60 int hammer_debug_critical;              /* non-zero enter debugger on error */
61 int hammer_cluster_enable = 1;          /* enable read clustering by default */
62 int hammer_count_fsyncs;
63 int hammer_count_inodes;
64 int hammer_count_iqueued;
65 int hammer_count_reclaiming;
66 int hammer_count_records;
67 int hammer_count_record_datas;
68 int hammer_count_volumes;
69 int hammer_count_buffers;
70 int hammer_count_nodes;
71 int64_t hammer_count_extra_space_used;
72 int64_t hammer_stats_btree_lookups;
73 int64_t hammer_stats_btree_searches;
74 int64_t hammer_stats_btree_inserts;
75 int64_t hammer_stats_btree_deletes;
76 int64_t hammer_stats_btree_elements;
77 int64_t hammer_stats_btree_splits;
78 int64_t hammer_stats_btree_iterations;
79 int64_t hammer_stats_btree_root_iterations;
80 int64_t hammer_stats_record_iterations;
81
82 int64_t hammer_stats_file_read;
83 int64_t hammer_stats_file_write;
84 int64_t hammer_stats_file_iopsr;
85 int64_t hammer_stats_file_iopsw;
86 int64_t hammer_stats_disk_read;
87 int64_t hammer_stats_disk_write;
88 int64_t hammer_stats_inode_flushes;
89 int64_t hammer_stats_commits;
90 int64_t hammer_stats_undo;
91
92 int hammer_count_dirtybufspace;         /* global */
93 int hammer_count_refedbufs;             /* global */
94 int hammer_count_reservations;
95 int hammer_count_io_running_read;
96 int hammer_count_io_running_write;
97 int hammer_count_io_locked;
98 int hammer_limit_dirtybufspace;         /* per-mount */
99 int hammer_limit_recs;                  /* as a whole XXX */
100 int hammer_limit_inode_recs = 1024;     /* per inode */
101 int hammer_limit_reclaim = HAMMER_RECLAIM_WAIT;
102 int hammer_autoflush = 2000;            /* auto flush */
103 int hammer_bio_count;
104 int hammer_verify_zone;
105 int hammer_verify_data = 1;
106 int hammer_write_mode;
107 int hammer_yield_check = 16;
108 int hammer_fsync_mode;
109 int64_t hammer_contention_count;
110 int64_t hammer_zone_limit;
111
112 SYSCTL_NODE(_vfs, OID_AUTO, hammer, CTLFLAG_RW, 0, "HAMMER filesystem");
113 SYSCTL_INT(_vfs_hammer, OID_AUTO, supported_version, CTLFLAG_RD,
114            &hammer_supported_version, 0, "");
115 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_general, CTLFLAG_RW,
116            &hammer_debug_general, 0, "");
117 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_io, CTLFLAG_RW,
118            &hammer_debug_io, 0, "");
119 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_debug, CTLFLAG_RW,
120            &hammer_debug_debug, 0, "");
121 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_inode, CTLFLAG_RW,
122            &hammer_debug_inode, 0, "");
123 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_locks, CTLFLAG_RW,
124            &hammer_debug_locks, 0, "");
125 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_btree, CTLFLAG_RW,
126            &hammer_debug_btree, 0, "");
127 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_tid, CTLFLAG_RW,
128            &hammer_debug_tid, 0, "");
129 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_recover, CTLFLAG_RW,
130            &hammer_debug_recover, 0, "");
131 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_recover_faults, CTLFLAG_RW,
132            &hammer_debug_recover_faults, 0, "");
133 SYSCTL_INT(_vfs_hammer, OID_AUTO, debug_critical, CTLFLAG_RW,
134            &hammer_debug_critical, 0, "");
135 SYSCTL_INT(_vfs_hammer, OID_AUTO, cluster_enable, CTLFLAG_RW,
136            &hammer_cluster_enable, 0, "");
137
138 SYSCTL_INT(_vfs_hammer, OID_AUTO, limit_dirtybufspace, CTLFLAG_RW,
139            &hammer_limit_dirtybufspace, 0, "");
140 SYSCTL_INT(_vfs_hammer, OID_AUTO, limit_recs, CTLFLAG_RW,
141            &hammer_limit_recs, 0, "");
142 SYSCTL_INT(_vfs_hammer, OID_AUTO, limit_inode_recs, CTLFLAG_RW,
143            &hammer_limit_inode_recs, 0, "");
144 SYSCTL_INT(_vfs_hammer, OID_AUTO, limit_reclaim, CTLFLAG_RW,
145            &hammer_limit_reclaim, 0, "");
146
147 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_fsyncs, CTLFLAG_RD,
148            &hammer_count_fsyncs, 0, "");
149 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_inodes, CTLFLAG_RD,
150            &hammer_count_inodes, 0, "");
151 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_iqueued, CTLFLAG_RD,
152            &hammer_count_iqueued, 0, "");
153 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_reclaiming, CTLFLAG_RD,
154            &hammer_count_reclaiming, 0, "");
155 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_records, CTLFLAG_RD,
156            &hammer_count_records, 0, "");
157 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_record_datas, CTLFLAG_RD,
158            &hammer_count_record_datas, 0, "");
159 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_volumes, CTLFLAG_RD,
160            &hammer_count_volumes, 0, "");
161 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_buffers, CTLFLAG_RD,
162            &hammer_count_buffers, 0, "");
163 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_nodes, CTLFLAG_RD,
164            &hammer_count_nodes, 0, "");
165 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, count_extra_space_used, CTLFLAG_RD,
166            &hammer_count_extra_space_used, 0, "");
167
168 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_searches, CTLFLAG_RD,
169            &hammer_stats_btree_searches, 0, "");
170 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_lookups, CTLFLAG_RD,
171            &hammer_stats_btree_lookups, 0, "");
172 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_inserts, CTLFLAG_RD,
173            &hammer_stats_btree_inserts, 0, "");
174 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_deletes, CTLFLAG_RD,
175            &hammer_stats_btree_deletes, 0, "");
176 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_elements, CTLFLAG_RD,
177            &hammer_stats_btree_elements, 0, "");
178 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_splits, CTLFLAG_RD,
179            &hammer_stats_btree_splits, 0, "");
180 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_iterations, CTLFLAG_RD,
181            &hammer_stats_btree_iterations, 0, "");
182 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_btree_root_iterations, CTLFLAG_RD,
183            &hammer_stats_btree_root_iterations, 0, "");
184 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_record_iterations, CTLFLAG_RD,
185            &hammer_stats_record_iterations, 0, "");
186
187 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_file_read, CTLFLAG_RD,
188            &hammer_stats_file_read, 0, "");
189 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_file_write, CTLFLAG_RD,
190            &hammer_stats_file_write, 0, "");
191 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_file_iopsr, CTLFLAG_RD,
192            &hammer_stats_file_iopsr, 0, "");
193 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_file_iopsw, CTLFLAG_RD,
194            &hammer_stats_file_iopsw, 0, "");
195 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_disk_read, CTLFLAG_RD,
196            &hammer_stats_disk_read, 0, "");
197 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_disk_write, CTLFLAG_RD,
198            &hammer_stats_disk_write, 0, "");
199 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_inode_flushes, CTLFLAG_RD,
200            &hammer_stats_inode_flushes, 0, "");
201 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_commits, CTLFLAG_RD,
202            &hammer_stats_commits, 0, "");
203 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, stats_undo, CTLFLAG_RD,
204            &hammer_stats_undo, 0, "");
205
206 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_dirtybufspace, CTLFLAG_RD,
207            &hammer_count_dirtybufspace, 0, "");
208 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_refedbufs, CTLFLAG_RD,
209            &hammer_count_refedbufs, 0, "");
210 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_reservations, CTLFLAG_RD,
211            &hammer_count_reservations, 0, "");
212 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_io_running_read, CTLFLAG_RD,
213            &hammer_count_io_running_read, 0, "");
214 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_io_locked, CTLFLAG_RD,
215            &hammer_count_io_locked, 0, "");
216 SYSCTL_INT(_vfs_hammer, OID_AUTO, count_io_running_write, CTLFLAG_RD,
217            &hammer_count_io_running_write, 0, "");
218 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, zone_limit, CTLFLAG_RW,
219            &hammer_zone_limit, 0, "");
220 SYSCTL_QUAD(_vfs_hammer, OID_AUTO, contention_count, CTLFLAG_RW,
221            &hammer_contention_count, 0, "");
222 SYSCTL_INT(_vfs_hammer, OID_AUTO, autoflush, CTLFLAG_RW,
223            &hammer_autoflush, 0, "");
224 SYSCTL_INT(_vfs_hammer, OID_AUTO, verify_zone, CTLFLAG_RW,
225            &hammer_verify_zone, 0, "");
226 SYSCTL_INT(_vfs_hammer, OID_AUTO, verify_data, CTLFLAG_RW,
227            &hammer_verify_data, 0, "");
228 SYSCTL_INT(_vfs_hammer, OID_AUTO, write_mode, CTLFLAG_RW,
229            &hammer_write_mode, 0, "");
230 SYSCTL_INT(_vfs_hammer, OID_AUTO, yield_check, CTLFLAG_RW,
231            &hammer_yield_check, 0, "");
232 SYSCTL_INT(_vfs_hammer, OID_AUTO, fsync_mode, CTLFLAG_RW,
233            &hammer_fsync_mode, 0, "");
234
235 KTR_INFO_MASTER(hammer);
236
237 /*
238  * VFS ABI
239  */
240 static void     hammer_free_hmp(struct mount *mp);
241
242 static int      hammer_vfs_mount(struct mount *mp, char *path, caddr_t data,
243                                 struct ucred *cred);
244 static int      hammer_vfs_unmount(struct mount *mp, int mntflags);
245 static int      hammer_vfs_root(struct mount *mp, struct vnode **vpp);
246 static int      hammer_vfs_statfs(struct mount *mp, struct statfs *sbp,
247                                 struct ucred *cred);
248 static int      hammer_vfs_statvfs(struct mount *mp, struct statvfs *sbp,
249                                 struct ucred *cred);
250 static int      hammer_vfs_sync(struct mount *mp, int waitfor);
251 static int      hammer_vfs_vget(struct mount *mp, struct vnode *dvp,
252                                 ino_t ino, struct vnode **vpp);
253 static int      hammer_vfs_init(struct vfsconf *conf);
254 static int      hammer_vfs_fhtovp(struct mount *mp, struct vnode *rootvp,
255                                 struct fid *fhp, struct vnode **vpp);
256 static int      hammer_vfs_vptofh(struct vnode *vp, struct fid *fhp);
257 static int      hammer_vfs_checkexp(struct mount *mp, struct sockaddr *nam,
258                                 int *exflagsp, struct ucred **credanonp);
259
260
261 static struct vfsops hammer_vfsops = {
262         .vfs_mount      = hammer_vfs_mount,
263         .vfs_unmount    = hammer_vfs_unmount,
264         .vfs_root       = hammer_vfs_root,
265         .vfs_statfs     = hammer_vfs_statfs,
266         .vfs_statvfs    = hammer_vfs_statvfs,
267         .vfs_sync       = hammer_vfs_sync,
268         .vfs_vget       = hammer_vfs_vget,
269         .vfs_init       = hammer_vfs_init,
270         .vfs_vptofh     = hammer_vfs_vptofh,
271         .vfs_fhtovp     = hammer_vfs_fhtovp,
272         .vfs_checkexp   = hammer_vfs_checkexp
273 };
274
275 MALLOC_DEFINE(M_HAMMER, "HAMMER-mount", "");
276
277 VFS_SET(hammer_vfsops, hammer, 0);
278 MODULE_VERSION(hammer, 1);
279
280 static int
281 hammer_vfs_init(struct vfsconf *conf)
282 {
283         int n;
284
285         if (hammer_limit_recs == 0) {
286                 hammer_limit_recs = nbuf * 25;
287                 n = kmalloc_limit(M_HAMMER) / 512;
288                 if (hammer_limit_recs > n)
289                         hammer_limit_recs = n;
290         }
291         if (hammer_limit_dirtybufspace == 0) {
292                 hammer_limit_dirtybufspace = hidirtybufspace / 2;
293                 if (hammer_limit_dirtybufspace < 100)
294                         hammer_limit_dirtybufspace = 100;
295         }
296         return(0);
297 }
298
299 static int
300 hammer_vfs_mount(struct mount *mp, char *mntpt, caddr_t data,
301                  struct ucred *cred)
302 {
303         struct hammer_mount_info info;
304         hammer_mount_t hmp;
305         hammer_volume_t rootvol;
306         struct vnode *rootvp;
307         struct vnode *devvp = NULL;
308         const char *upath;      /* volume name in userspace */
309         char *path;             /* volume name in system space */
310         int error;
311         int i;
312         int master_id;
313         int maxinodes;
314         char *next_volume_ptr = NULL;
315
316         /*
317          * Accept hammer_mount_info.  mntpt is NULL for root mounts at boot.
318          */
319         if (mntpt == NULL) {
320                 bzero(&info, sizeof(info));
321                 info.asof = 0;
322                 info.hflags = 0;
323                 info.nvolumes = 1;
324
325                 next_volume_ptr = mp->mnt_stat.f_mntfromname;
326
327                 /* Count number of volumes separated by ':' */
328                 for (char *p = next_volume_ptr; *p != '\0'; ++p) {
329                         if (*p == ':') {
330                                 ++info.nvolumes;
331                         }
332                 }
333
334                 mp->mnt_flag &= ~MNT_RDONLY; /* mount R/W */
335         } else {
336                 if ((error = copyin(data, &info, sizeof(info))) != 0)
337                         return (error);
338         }
339
340         /*
341          * updating or new mount
342          */
343         if (mp->mnt_flag & MNT_UPDATE) {
344                 hmp = (void *)mp->mnt_data;
345                 KKASSERT(hmp != NULL);
346         } else {
347                 if (info.nvolumes <= 0 || info.nvolumes >= 32768)
348                         return (EINVAL);
349                 hmp = NULL;
350         }
351
352         /*
353          * master-id validation.  The master id may not be changed by a
354          * mount update.
355          */
356         if (info.hflags & HMNT_MASTERID) {
357                 if (hmp && hmp->master_id != info.master_id) {
358                         kprintf("hammer: cannot change master id "
359                                 "with mount update\n");
360                         return(EINVAL);
361                 }
362                 master_id = info.master_id;
363                 if (master_id < -1 || master_id >= HAMMER_MAX_MASTERS)
364                         return (EINVAL);
365         } else {
366                 if (hmp)
367                         master_id = hmp->master_id;
368                 else
369                         master_id = 0;
370         }
371
372         /*
373          * Interal mount data structure
374          */
375         if (hmp == NULL) {
376                 hmp = kmalloc(sizeof(*hmp), M_HAMMER, M_WAITOK | M_ZERO);
377                 mp->mnt_data = (qaddr_t)hmp;
378                 hmp->mp = mp;
379                 /*TAILQ_INIT(&hmp->recycle_list);*/
380
381                 /*
382                  * Make sure kmalloc type limits are set appropriately.  If root
383                  * increases the vnode limit you may have to do a dummy remount
384                  * to adjust the HAMMER inode limit.
385                  */
386                 kmalloc_create(&hmp->m_misc, "HAMMER-others");
387                 kmalloc_create(&hmp->m_inodes, "HAMMER-inodes");
388
389                 maxinodes = desiredvnodes + desiredvnodes / 5 +
390                             hammer_limit_reclaim * 2;
391                 kmalloc_raise_limit(hmp->m_inodes,
392                                     maxinodes * sizeof(struct hammer_inode));
393
394                 hmp->root_btree_beg.localization = 0x00000000U;
395                 hmp->root_btree_beg.obj_id = -0x8000000000000000LL;
396                 hmp->root_btree_beg.key = -0x8000000000000000LL;
397                 hmp->root_btree_beg.create_tid = 1;
398                 hmp->root_btree_beg.delete_tid = 1;
399                 hmp->root_btree_beg.rec_type = 0;
400                 hmp->root_btree_beg.obj_type = 0;
401
402                 hmp->root_btree_end.localization = 0xFFFFFFFFU;
403                 hmp->root_btree_end.obj_id = 0x7FFFFFFFFFFFFFFFLL;
404                 hmp->root_btree_end.key = 0x7FFFFFFFFFFFFFFFLL;
405                 hmp->root_btree_end.create_tid = 0xFFFFFFFFFFFFFFFFULL;
406                 hmp->root_btree_end.delete_tid = 0;   /* special case */
407                 hmp->root_btree_end.rec_type = 0xFFFFU;
408                 hmp->root_btree_end.obj_type = 0;
409
410                 hmp->krate.freq = 1;    /* maximum reporting rate (hz) */
411                 hmp->krate.count = -16; /* initial burst */
412
413                 hmp->sync_lock.refs = 1;
414                 hmp->free_lock.refs = 1;
415                 hmp->undo_lock.refs = 1;
416                 hmp->blkmap_lock.refs = 1;
417                 hmp->snapshot_lock.refs = 1;
418
419                 TAILQ_INIT(&hmp->delay_list);
420                 TAILQ_INIT(&hmp->flush_group_list);
421                 TAILQ_INIT(&hmp->objid_cache_list);
422                 TAILQ_INIT(&hmp->undo_lru_list);
423                 TAILQ_INIT(&hmp->reclaim_list);
424         }
425         hmp->hflags &= ~HMNT_USERFLAGS;
426         hmp->hflags |= info.hflags & HMNT_USERFLAGS;
427
428         hmp->master_id = master_id;
429
430         if (info.asof) {
431                 mp->mnt_flag |= MNT_RDONLY;
432                 hmp->asof = info.asof;
433         } else {
434                 hmp->asof = HAMMER_MAX_TID;
435         }
436
437         /*
438          * Re-open read-write if originally read-only, or vise-versa.
439          *
440          * When going from read-only to read-write execute the stage2
441          * recovery if it has not already been run.
442          */
443         if (mp->mnt_flag & MNT_UPDATE) {
444                 error = 0;
445                 if (hmp->ronly && (mp->mnt_kern_flag & MNTK_WANTRDWR)) {
446                         kprintf("HAMMER read-only -> read-write\n");
447                         hmp->ronly = 0;
448                         RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
449                                 hammer_adjust_volume_mode, NULL);
450                         rootvol = hammer_get_root_volume(hmp, &error);
451                         if (rootvol) {
452                                 hammer_recover_flush_buffers(hmp, rootvol, 1);
453                                 error = hammer_recover_stage2(hmp, rootvol);
454                                 bcopy(rootvol->ondisk->vol0_blockmap,
455                                       hmp->blockmap,
456                                       sizeof(hmp->blockmap));
457                                 hammer_rel_volume(rootvol, 0);
458                         }
459                         RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
460                                 hammer_reload_inode, NULL);
461                         /* kernel clears MNT_RDONLY */
462                 } else if (hmp->ronly == 0 && (mp->mnt_flag & MNT_RDONLY)) {
463                         kprintf("HAMMER read-write -> read-only\n");
464                         hmp->ronly = 1; /* messy */
465                         RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
466                                 hammer_reload_inode, NULL);
467                         hmp->ronly = 0;
468                         hammer_flusher_sync(hmp);
469                         hammer_flusher_sync(hmp);
470                         hammer_flusher_sync(hmp);
471                         hmp->ronly = 1;
472                         RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
473                                 hammer_adjust_volume_mode, NULL);
474                 }
475                 return(error);
476         }
477
478         RB_INIT(&hmp->rb_vols_root);
479         RB_INIT(&hmp->rb_inos_root);
480         RB_INIT(&hmp->rb_nods_root);
481         RB_INIT(&hmp->rb_undo_root);
482         RB_INIT(&hmp->rb_resv_root);
483         RB_INIT(&hmp->rb_bufs_root);
484         RB_INIT(&hmp->rb_pfsm_root);
485
486         hmp->ronly = ((mp->mnt_flag & MNT_RDONLY) != 0);
487
488         TAILQ_INIT(&hmp->volu_list);
489         TAILQ_INIT(&hmp->undo_list);
490         TAILQ_INIT(&hmp->data_list);
491         TAILQ_INIT(&hmp->meta_list);
492         TAILQ_INIT(&hmp->lose_list);
493
494         /*
495          * Load volumes
496          */
497         path = objcache_get(namei_oc, M_WAITOK);
498         hmp->nvolumes = -1;
499         for (i = 0; i < info.nvolumes; ++i) {
500                 if (mntpt == NULL) {
501                         /*
502                          * Root mount.
503                          */
504                         KKASSERT(next_volume_ptr != NULL);
505                         strcpy(path, "/dev/");
506                         int k;
507                         for (k = strlen(path); k < MAXPATHLEN-1; ++k) {
508                                 if (*next_volume_ptr == '\0') {
509                                         break;
510                                 } else if (*next_volume_ptr == ':') {
511                                         ++next_volume_ptr;
512                                         break;
513                                 } else {
514                                         path[k] = *next_volume_ptr;
515                                         ++next_volume_ptr;
516                                 }
517                         }
518                         path[k] = '\0';
519
520                         error = 0;
521                         cdev_t dev = kgetdiskbyname(path);
522                         error = bdevvp(dev, &devvp);
523                         if (error) {
524                                 kprintf("hammer_mountroot: can't find devvp\n");
525                         }
526                 } else {
527                         error = copyin(&info.volumes[i], &upath,
528                                        sizeof(char *));
529                         if (error == 0)
530                                 error = copyinstr(upath, path,
531                                                   MAXPATHLEN, NULL);
532                 }
533                 if (error == 0)
534                         error = hammer_install_volume(hmp, path, devvp);
535                 if (error)
536                         break;
537         }
538         objcache_put(namei_oc, path);
539
540         /*
541          * Make sure we found a root volume
542          */
543         if (error == 0 && hmp->rootvol == NULL) {
544                 kprintf("hammer_mount: No root volume found!\n");
545                 error = EINVAL;
546         }
547
548         /*
549          * Check that all required volumes are available
550          */
551         if (error == 0 && hammer_mountcheck_volumes(hmp)) {
552                 kprintf("hammer_mount: Missing volumes, cannot mount!\n");
553                 error = EINVAL;
554         }
555
556         if (error) {
557                 hammer_free_hmp(mp);
558                 return (error);
559         }
560
561         /*
562          * No errors, setup enough of the mount point so we can lookup the
563          * root vnode.
564          */
565         mp->mnt_iosize_max = MAXPHYS;
566         mp->mnt_kern_flag |= MNTK_FSMID;
567
568         /* 
569          * note: f_iosize is used by vnode_pager_haspage() when constructing
570          * its VOP_BMAP call.
571          */
572         mp->mnt_stat.f_iosize = HAMMER_BUFSIZE;
573         mp->mnt_stat.f_bsize = HAMMER_BUFSIZE;
574
575         mp->mnt_vstat.f_frsize = HAMMER_BUFSIZE;
576         mp->mnt_vstat.f_bsize = HAMMER_BUFSIZE;
577
578         mp->mnt_maxsymlinklen = 255;
579         mp->mnt_flag |= MNT_LOCAL;
580
581         vfs_add_vnodeops(mp, &hammer_vnode_vops, &mp->mnt_vn_norm_ops);
582         vfs_add_vnodeops(mp, &hammer_spec_vops, &mp->mnt_vn_spec_ops);
583         vfs_add_vnodeops(mp, &hammer_fifo_vops, &mp->mnt_vn_fifo_ops);
584
585         /*
586          * The root volume's ondisk pointer is only valid if we hold a
587          * reference to it.
588          */
589         rootvol = hammer_get_root_volume(hmp, &error);
590         if (error)
591                 goto failed;
592
593         /*
594          * Perform any necessary UNDO operations.  The recovery code does
595          * call hammer_undo_lookup() so we have to pre-cache the blockmap,
596          * and then re-copy it again after recovery is complete.
597          *
598          * If this is a read-only mount the UNDO information is retained
599          * in memory in the form of dirty buffer cache buffers, and not
600          * written back to the media.
601          */
602         bcopy(rootvol->ondisk->vol0_blockmap, hmp->blockmap,
603               sizeof(hmp->blockmap));
604
605         /*
606          * Check filesystem version
607          */
608         hmp->version = rootvol->ondisk->vol_version;
609         if (hmp->version < HAMMER_VOL_VERSION_MIN ||
610             hmp->version > HAMMER_VOL_VERSION_MAX) {
611                 kprintf("HAMMER: mount unsupported fs version %d\n",
612                         hmp->version);
613                 error = ERANGE;
614                 goto done;
615         }
616
617         /*
618          * The undo_rec_limit limits the size of flush groups to avoid
619          * blowing out the UNDO FIFO.  This calculation is typically in
620          * the tens of thousands and is designed primarily when small
621          * HAMMER filesystems are created.
622          */
623         hmp->undo_rec_limit = hammer_undo_max(hmp) / 8192 + 100;
624         if (hammer_debug_general & 0x0001)
625                 kprintf("HAMMER: undo_rec_limit %d\n", hmp->undo_rec_limit);
626
627         /*
628          * NOTE: Recover stage1 not only handles meta-data recovery, it
629          *       also sets hmp->undo_seqno for HAMMER VERSION 4+ filesystems.
630          */
631         error = hammer_recover_stage1(hmp, rootvol);
632         if (error) {
633                 kprintf("Failed to recover HAMMER filesystem on mount\n");
634                 goto done;
635         }
636
637         /*
638          * Finish setup now that we have a good root volume.
639          *
640          * The top 16 bits of fsid.val[1] is a pfs id.
641          */
642         ksnprintf(mp->mnt_stat.f_mntfromname,
643                   sizeof(mp->mnt_stat.f_mntfromname), "%s",
644                   rootvol->ondisk->vol_name);
645         mp->mnt_stat.f_fsid.val[0] =
646                 crc32((char *)&rootvol->ondisk->vol_fsid + 0, 8);
647         mp->mnt_stat.f_fsid.val[1] =
648                 crc32((char *)&rootvol->ondisk->vol_fsid + 8, 8);
649         mp->mnt_stat.f_fsid.val[1] &= 0x0000FFFF;
650
651         mp->mnt_vstat.f_fsid_uuid = rootvol->ondisk->vol_fsid;
652         mp->mnt_vstat.f_fsid = crc32(&mp->mnt_vstat.f_fsid_uuid,
653                                      sizeof(mp->mnt_vstat.f_fsid_uuid));
654
655         /*
656          * Certain often-modified fields in the root volume are cached in
657          * the hammer_mount structure so we do not have to generate lots
658          * of little UNDO structures for them.
659          *
660          * Recopy after recovery.  This also has the side effect of
661          * setting our cached undo FIFO's first_offset, which serves to
662          * placemark the FIFO start for the NEXT flush cycle while the
663          * on-disk first_offset represents the LAST flush cycle.
664          */
665         hmp->next_tid = rootvol->ondisk->vol0_next_tid;
666         hmp->flush_tid1 = hmp->next_tid;
667         hmp->flush_tid2 = hmp->next_tid;
668         bcopy(rootvol->ondisk->vol0_blockmap, hmp->blockmap,
669               sizeof(hmp->blockmap));
670         hmp->copy_stat_freebigblocks = rootvol->ondisk->vol0_stat_freebigblocks;
671
672         hammer_flusher_create(hmp);
673
674         /*
675          * Locate the root directory using the root cluster's B-Tree as a
676          * starting point.  The root directory uses an obj_id of 1.
677          *
678          * FUTURE: Leave the root directory cached referenced but unlocked
679          * in hmp->rootvp (need to flush it on unmount).
680          */
681         error = hammer_vfs_vget(mp, NULL, 1, &rootvp);
682         if (error)
683                 goto done;
684         vput(rootvp);
685         /*vn_unlock(hmp->rootvp);*/
686         if (hmp->ronly == 0)
687                 error = hammer_recover_stage2(hmp, rootvol);
688
689 done:
690         hammer_rel_volume(rootvol, 0);
691 failed:
692         /*
693          * Cleanup and return.
694          */
695         if (error)
696                 hammer_free_hmp(mp);
697         return (error);
698 }
699
700 static int
701 hammer_vfs_unmount(struct mount *mp, int mntflags)
702 {
703 #if 0
704         struct hammer_mount *hmp = (void *)mp->mnt_data;
705 #endif
706         int flags;
707         int error;
708
709         /*
710          * Clean out the vnodes
711          */
712         flags = 0;
713         if (mntflags & MNT_FORCE)
714                 flags |= FORCECLOSE;
715         if ((error = vflush(mp, 0, flags)) != 0)
716                 return (error);
717
718         /*
719          * Clean up the internal mount structure and related entities.  This
720          * may issue I/O.
721          */
722         hammer_free_hmp(mp);
723         return(0);
724 }
725
726 /*
727  * Clean up the internal mount structure and disassociate it from the mount.
728  * This may issue I/O.
729  */
730 static void
731 hammer_free_hmp(struct mount *mp)
732 {
733         struct hammer_mount *hmp = (void *)mp->mnt_data;
734         hammer_flush_group_t flg;
735         int count;
736         int dummy;
737
738         /*
739          * Flush anything dirty.  This won't even run if the
740          * filesystem errored-out.
741          */
742         count = 0;
743         while (hammer_flusher_haswork(hmp)) {
744                 hammer_flusher_sync(hmp);
745                 ++count;
746                 if (count >= 5) {
747                         if (count == 5)
748                                 kprintf("HAMMER: umount flushing.");
749                         else
750                                 kprintf(".");
751                         tsleep(&dummy, 0, "hmrufl", hz);
752                 }
753                 if (count == 30) {
754                         kprintf("giving up\n");
755                         break;
756                 }
757         }
758         if (count >= 5 && count < 30)
759                 kprintf("\n");
760
761         /*
762          * If the mount had a critical error we have to destroy any
763          * remaining inodes before we can finish cleaning up the flusher.
764          */
765         if (hmp->flags & HAMMER_MOUNT_CRITICAL_ERROR) {
766                 RB_SCAN(hammer_ino_rb_tree, &hmp->rb_inos_root, NULL,
767                         hammer_destroy_inode_callback, NULL);
768         }
769
770         /*
771          * There shouldn't be any inodes left now and any left over
772          * flush groups should now be empty.
773          */
774         KKASSERT(RB_EMPTY(&hmp->rb_inos_root));
775         while ((flg = TAILQ_FIRST(&hmp->flush_group_list)) != NULL) {
776                 TAILQ_REMOVE(&hmp->flush_group_list, flg, flush_entry);
777                 KKASSERT(RB_EMPTY(&flg->flush_tree));
778                 if (flg->refs) {
779                         kprintf("HAMMER: Warning, flush_group %p was "
780                                 "not empty on umount!\n", flg);
781                 }
782                 kfree(flg, hmp->m_misc);
783         }
784
785         /*
786          * We can finally destroy the flusher
787          */
788         hammer_flusher_destroy(hmp);
789
790         /*
791          * We may have held recovered buffers due to a read-only mount.
792          * These must be discarded.
793          */
794         if (hmp->ronly)
795                 hammer_recover_flush_buffers(hmp, NULL, -1);
796
797         /*
798          * Unload buffers and then volumes
799          */
800         RB_SCAN(hammer_buf_rb_tree, &hmp->rb_bufs_root, NULL,
801                 hammer_unload_buffer, NULL);
802         RB_SCAN(hammer_vol_rb_tree, &hmp->rb_vols_root, NULL,
803                 hammer_unload_volume, NULL);
804
805         mp->mnt_data = NULL;
806         mp->mnt_flag &= ~MNT_LOCAL;
807         hmp->mp = NULL;
808         hammer_destroy_objid_cache(hmp);
809         kmalloc_destroy(&hmp->m_misc);
810         kmalloc_destroy(&hmp->m_inodes);
811         kfree(hmp, M_HAMMER);
812 }
813
814 /*
815  * Report critical errors.  ip may be NULL.
816  */
817 void
818 hammer_critical_error(hammer_mount_t hmp, hammer_inode_t ip,
819                       int error, const char *msg)
820 {
821         hmp->flags |= HAMMER_MOUNT_CRITICAL_ERROR;
822
823         krateprintf(&hmp->krate,
824                     "HAMMER(%s): Critical error inode=%jd error=%d %s\n",
825                     hmp->mp->mnt_stat.f_mntfromname,
826                     (intmax_t)(ip ? ip->obj_id : -1),
827                     error, msg);
828
829         if (hmp->ronly == 0) {
830                 hmp->ronly = 2;         /* special errored read-only mode */
831                 hmp->mp->mnt_flag |= MNT_RDONLY;
832                 kprintf("HAMMER(%s): Forcing read-only mode\n",
833                         hmp->mp->mnt_stat.f_mntfromname);
834         }
835         hmp->error = error;
836         if (hammer_debug_critical)
837                 Debugger("Entering debugger");
838 }
839
840
841 /*
842  * Obtain a vnode for the specified inode number.  An exclusively locked
843  * vnode is returned.
844  */
845 int
846 hammer_vfs_vget(struct mount *mp, struct vnode *dvp,
847                 ino_t ino, struct vnode **vpp)
848 {
849         struct hammer_transaction trans;
850         struct hammer_mount *hmp = (void *)mp->mnt_data;
851         struct hammer_inode *ip;
852         int error;
853         u_int32_t localization;
854
855         hammer_simple_transaction(&trans, hmp);
856
857         /*
858          * If a directory vnode is supplied (mainly NFS) then we can acquire
859          * the PFS domain from it.  Otherwise we would only be able to vget
860          * inodes in the root PFS.
861          */
862         if (dvp) {
863                 localization = HAMMER_DEF_LOCALIZATION +
864                                 VTOI(dvp)->obj_localization;
865         } else {
866                 localization = HAMMER_DEF_LOCALIZATION;
867         }
868
869         /*
870          * Lookup the requested HAMMER inode.  The structure must be
871          * left unlocked while we manipulate the related vnode to avoid
872          * a deadlock.
873          */
874         ip = hammer_get_inode(&trans, NULL, ino,
875                               hmp->asof, localization,
876                               0, &error);
877         if (ip == NULL) {
878                 *vpp = NULL;
879                 hammer_done_transaction(&trans);
880                 return(error);
881         }
882         error = hammer_get_vnode(ip, vpp);
883         hammer_rel_inode(ip, 0);
884         hammer_done_transaction(&trans);
885         return (error);
886 }
887
888 /*
889  * Return the root vnode for the filesystem.
890  *
891  * HAMMER stores the root vnode in the hammer_mount structure so
892  * getting it is easy.
893  */
894 static int
895 hammer_vfs_root(struct mount *mp, struct vnode **vpp)
896 {
897 #if 0
898         struct hammer_mount *hmp = (void *)mp->mnt_data;
899 #endif
900         int error;
901
902         error = hammer_vfs_vget(mp, NULL, 1, vpp);
903         return (error);
904 }
905
906 static int
907 hammer_vfs_statfs(struct mount *mp, struct statfs *sbp, struct ucred *cred)
908 {
909         struct hammer_mount *hmp = (void *)mp->mnt_data;
910         hammer_volume_t volume;
911         hammer_volume_ondisk_t ondisk;
912         int error;
913         int64_t bfree;
914         int64_t breserved;
915
916         volume = hammer_get_root_volume(hmp, &error);
917         if (error)
918                 return(error);
919         ondisk = volume->ondisk;
920
921         /*
922          * Basic stats
923          */
924         _hammer_checkspace(hmp, HAMMER_CHKSPC_WRITE, &breserved);
925         mp->mnt_stat.f_files = ondisk->vol0_stat_inodes;
926         bfree = ondisk->vol0_stat_freebigblocks * HAMMER_LARGEBLOCK_SIZE;
927         hammer_rel_volume(volume, 0);
928
929         mp->mnt_stat.f_bfree = (bfree - breserved) / HAMMER_BUFSIZE;
930         mp->mnt_stat.f_bavail = mp->mnt_stat.f_bfree;
931         if (mp->mnt_stat.f_files < 0)
932                 mp->mnt_stat.f_files = 0;
933
934         *sbp = mp->mnt_stat;
935         return(0);
936 }
937
938 static int
939 hammer_vfs_statvfs(struct mount *mp, struct statvfs *sbp, struct ucred *cred)
940 {
941         struct hammer_mount *hmp = (void *)mp->mnt_data;
942         hammer_volume_t volume;
943         hammer_volume_ondisk_t ondisk;
944         int error;
945         int64_t bfree;
946         int64_t breserved;
947
948         volume = hammer_get_root_volume(hmp, &error);
949         if (error)
950                 return(error);
951         ondisk = volume->ondisk;
952
953         /*
954          * Basic stats
955          */
956         _hammer_checkspace(hmp, HAMMER_CHKSPC_WRITE, &breserved);
957         mp->mnt_vstat.f_files = ondisk->vol0_stat_inodes;
958         bfree = ondisk->vol0_stat_freebigblocks * HAMMER_LARGEBLOCK_SIZE;
959         hammer_rel_volume(volume, 0);
960
961         mp->mnt_vstat.f_bfree = (bfree - breserved) / HAMMER_BUFSIZE;
962         mp->mnt_vstat.f_bavail = mp->mnt_vstat.f_bfree;
963         if (mp->mnt_vstat.f_files < 0)
964                 mp->mnt_vstat.f_files = 0;
965         *sbp = mp->mnt_vstat;
966         return(0);
967 }
968
969 /*
970  * Sync the filesystem.  Currently we have to run it twice, the second
971  * one will advance the undo start index to the end index, so if a crash
972  * occurs no undos will be run on mount.
973  *
974  * We do not sync the filesystem if we are called from a panic.  If we did
975  * we might end up blowing up a sync that was already in progress.
976  */
977 static int
978 hammer_vfs_sync(struct mount *mp, int waitfor)
979 {
980         struct hammer_mount *hmp = (void *)mp->mnt_data;
981         int error;
982
983         if (panicstr == NULL) {
984                 error = hammer_sync_hmp(hmp, waitfor);
985         } else {
986                 error = EIO;
987         }
988         return (error);
989 }
990
991 /*
992  * Convert a vnode to a file handle.
993  */
994 static int
995 hammer_vfs_vptofh(struct vnode *vp, struct fid *fhp)
996 {
997         hammer_inode_t ip;
998
999         KKASSERT(MAXFIDSZ >= 16);
1000         ip = VTOI(vp);
1001         fhp->fid_len = offsetof(struct fid, fid_data[16]);
1002         fhp->fid_ext = ip->obj_localization >> 16;
1003         bcopy(&ip->obj_id, fhp->fid_data + 0, sizeof(ip->obj_id));
1004         bcopy(&ip->obj_asof, fhp->fid_data + 8, sizeof(ip->obj_asof));
1005         return(0);
1006 }
1007
1008
1009 /*
1010  * Convert a file handle back to a vnode.
1011  *
1012  * Use rootvp to enforce PFS isolation when a PFS is exported via a
1013  * null mount.
1014  */
1015 static int
1016 hammer_vfs_fhtovp(struct mount *mp, struct vnode *rootvp,
1017                   struct fid *fhp, struct vnode **vpp)
1018 {
1019         struct hammer_transaction trans;
1020         struct hammer_inode *ip;
1021         struct hammer_inode_info info;
1022         int error;
1023         u_int32_t localization;
1024
1025         bcopy(fhp->fid_data + 0, &info.obj_id, sizeof(info.obj_id));
1026         bcopy(fhp->fid_data + 8, &info.obj_asof, sizeof(info.obj_asof));
1027         if (rootvp)
1028                 localization = VTOI(rootvp)->obj_localization;
1029         else
1030                 localization = (u_int32_t)fhp->fid_ext << 16;
1031
1032         hammer_simple_transaction(&trans, (void *)mp->mnt_data);
1033
1034         /*
1035          * Get/allocate the hammer_inode structure.  The structure must be
1036          * unlocked while we manipulate the related vnode to avoid a
1037          * deadlock.
1038          */
1039         ip = hammer_get_inode(&trans, NULL, info.obj_id,
1040                               info.obj_asof, localization, 0, &error);
1041         if (ip == NULL) {
1042                 *vpp = NULL;
1043                 return(error);
1044         }
1045         error = hammer_get_vnode(ip, vpp);
1046         hammer_rel_inode(ip, 0);
1047         hammer_done_transaction(&trans);
1048         return (error);
1049 }
1050
1051 static int
1052 hammer_vfs_checkexp(struct mount *mp, struct sockaddr *nam,
1053                     int *exflagsp, struct ucred **credanonp)
1054 {
1055         hammer_mount_t hmp = (void *)mp->mnt_data;
1056         struct netcred *np;
1057         int error;
1058
1059         np = vfs_export_lookup(mp, &hmp->export, nam);
1060         if (np) {
1061                 *exflagsp = np->netc_exflags;
1062                 *credanonp = &np->netc_anon;
1063                 error = 0;
1064         } else {
1065                 error = EACCES;
1066         }
1067         return (error);
1068
1069 }
1070
1071 int
1072 hammer_vfs_export(struct mount *mp, int op, const struct export_args *export)
1073 {
1074         hammer_mount_t hmp = (void *)mp->mnt_data;
1075         int error;
1076
1077         switch(op) {
1078         case MOUNTCTL_SET_EXPORT:
1079                 error = vfs_export(mp, &hmp->export, export);
1080                 break;
1081         default:
1082                 error = EOPNOTSUPP;
1083                 break;
1084         }
1085         return(error);
1086 }
1087