hammer2 - followup cleanup
[dragonfly.git] / sys / vfs / hammer2 / hammer2_vnops.c
1 /*
2  * Copyright (c) 2011-2012 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@dragonflybsd.org>
6  * by Venkatesh Srinivas <vsrinivas@dragonflybsd.org>
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  * 3. Neither the name of The DragonFly Project nor the names of its
19  *    contributors may be used to endorse or promote products derived
20  *    from this software without specific, prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/fcntl.h>
39 #include <sys/buf.h>
40 #include <sys/proc.h>
41 #include <sys/namei.h>
42 #include <sys/mount.h>
43 #include <sys/vnode.h>
44 #include <sys/mountctl.h>
45
46 #include "hammer2.h"
47
48 /*
49  * Last reference to a vnode is going away but it is still cached.
50  */
51 static
52 int
53 hammer2_vop_inactive(struct vop_inactive_args *ap)
54 {
55         struct vnode *vp;
56         struct hammer2_inode *ip;
57 #if 0
58         struct hammer2_mount *hmp;
59 #endif
60
61         kprintf("hammer2_inactive\n");
62
63         vp = ap->a_vp;
64         ip = VTOI(vp);
65
66         return (0);
67 }
68
69 /*
70  * Reclaim a vnode so that it can be reused; after the inode is
71  * disassociated, the filesystem must manage it alone.
72  */
73 static
74 int
75 hammer2_vop_reclaim(struct vop_reclaim_args *ap)
76 {
77         struct vnode *vp;
78         struct hammer2_inode *ip;
79         struct hammer2_mount *hmp;
80
81         vp = ap->a_vp;
82         ip = VTOI(vp);
83         hmp = ip->hmp;
84
85         hammer2_inode_lock_ex(ip);
86         vp->v_data = NULL;
87         ip->vp = NULL;
88         hammer2_inode_unlock_ex(ip);
89
90         /*
91          * XXX handle background sync when ip dirty, kernel will no longer
92          * notify us regarding this inode because there is no longer a
93          * vnode attached to it.
94          */
95
96         return (0);
97 }
98
99 static
100 int
101 hammer2_vop_fsync(struct vop_fsync_args *ap)
102 {
103         kprintf("hammer2_fsync\n");
104         return (EOPNOTSUPP);
105 }
106
107 static
108 int
109 hammer2_vop_access(struct vop_access_args *ap)
110 {
111         kprintf("hammer2_access\n");
112         return (0);
113 }
114
115 static
116 int
117 hammer2_vop_getattr(struct vop_getattr_args *ap)
118 {
119         struct vnode *vp;
120         struct vattr *vap;
121         struct hammer2_inode *ip;
122
123         vp = ap->a_vp;
124         vap = ap->a_vap;
125
126         kprintf("hammer2_getattr\n");
127
128         ip = VTOI(vp);
129         hammer2_inode_lock_sh(ip);
130
131         vap->va_type = vp->v_type;
132         vap->va_mode = 0777;
133         vap->va_nlink = 1;
134         vap->va_uid = 0;
135         vap->va_gid = 0;
136         vap->va_size = 0;
137         vap->va_blocksize = PAGE_SIZE;
138         vap->va_flags = 0;
139
140         hammer2_inode_unlock_sh(ip);
141
142         return (0);
143 }
144
145 static
146 int
147 hammer2_vop_readdir(struct vop_readdir_args *ap)
148 {
149         kprintf("hammer2_readdir\n");
150         return (EOPNOTSUPP);
151 }
152
153 static
154 int
155 hammer2_vop_read(struct vop_read_args *ap)
156 {
157         return (EOPNOTSUPP);
158 }
159
160 static
161 int
162 hammer2_vop_write(struct vop_write_args *ap)
163 {
164         return (EOPNOTSUPP);
165 }
166
167 static
168 int
169 hammer2_vop_nresolve(struct vop_nresolve_args *ap)
170 {
171         kprintf("hammer2_nresolve\n");
172         return (EOPNOTSUPP);
173 }
174
175 static
176 int
177 hammer2_vop_bmap(struct vop_bmap_args *ap)
178 {
179         kprintf("hammer2_bmap\n");
180         return (EOPNOTSUPP);
181 }
182
183 static
184 int
185 hammer2_vop_open(struct vop_open_args *ap)
186 {
187         kprintf("hammer2_open\n");
188         return vop_stdopen(ap);
189 }
190
191 static
192 int
193 hammer2_vop_strategy(struct vop_strategy_args *ap)
194 {
195         struct vnode *vp;
196         struct bio *biop;
197         struct buf *bp;
198         struct hammer2_inode *ip;
199         int error;
200
201         vp = ap->a_vp;
202         biop = ap->a_bio;
203         bp = biop->bio_buf;
204         ip = VTOI(vp);
205
206         switch(bp->b_cmd) {
207         case (BUF_CMD_READ):
208         case (BUF_CMD_WRITE):
209         default:
210                 bp->b_error = error = EINVAL;
211                 bp->b_flags |= B_ERROR;
212                 biodone(biop);
213                 break;
214         }
215
216         return (error);
217 }
218
219 static
220 int 
221 hammer2_vop_mountctl(struct vop_mountctl_args *ap)
222 {
223         struct mount *mp;
224         struct hammer2_mount *hmp;
225         int rc;
226
227         switch (ap->a_op) {
228         case (MOUNTCTL_SET_EXPORT):
229                 mp = ap->a_head.a_ops->head.vv_mount;
230                 hmp = MPTOH2(mp);
231
232                 if (ap->a_ctllen != sizeof(struct export_args))
233                         rc = (EINVAL);
234                 else
235                         rc = vfs_export(mp, &hmp->export,
236                                         (const struct export_args *)ap->a_ctl);
237                 break;
238         default:
239                 rc = vop_stdmountctl(ap);
240                 break;
241         }
242         return (rc);
243 }
244
245 struct vop_ops hammer2_vnode_vops = {
246         .vop_default    = vop_defaultop,
247         .vop_fsync      = hammer2_vop_fsync,
248         .vop_getpages   = vop_stdgetpages,
249         .vop_putpages   = vop_stdputpages,
250         .vop_access     = hammer2_vop_access,
251         .vop_getattr    = hammer2_vop_getattr,
252         .vop_readdir    = hammer2_vop_readdir,
253         .vop_read       = hammer2_vop_read,
254         .vop_write      = hammer2_vop_write,
255         .vop_open       = hammer2_vop_open,
256         .vop_inactive   = hammer2_vop_inactive,
257         .vop_reclaim    = hammer2_vop_reclaim,
258         .vop_nresolve   = hammer2_vop_nresolve,
259         .vop_mountctl   = hammer2_vop_mountctl,
260         .vop_bmap       = hammer2_vop_bmap,
261         .vop_strategy   = hammer2_vop_strategy,
262 };
263
264 struct vop_ops hammer2_spec_vops = {
265
266 };
267
268 struct vop_ops hammer2_fifo_vops = {
269
270 };