Merge from vendor branch LESS:
[dragonfly.git] / sys / vfs / hammer / hammer_inode.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_inode.c,v 1.6 2007/11/20 22:55:40 dillon Exp $
35  */
36
37 #include "hammer.h"
38 #include <sys/buf.h>
39 #include <sys/buf2.h>
40
41 int
42 hammer_vop_inactive(struct vop_inactive_args *ap)
43 {
44         struct hammer_inode *ip = VTOI(ap->a_vp);
45
46         if (ip == NULL)
47                 vrecycle(ap->a_vp);
48         return(0);
49 }
50
51 int
52 hammer_vop_reclaim(struct vop_reclaim_args *ap)
53 {
54         struct hammer_inode *ip;
55         struct vnode *vp;
56
57         vp = ap->a_vp;
58         if ((ip = vp->v_data) != NULL) {
59                 vp->v_data = NULL;
60                 ip->vp = NULL;
61                 hammer_rel_inode(ip, 1);
62         }
63         return(0);
64 }
65
66 /*
67  * Obtain a vnode for the specified inode number.  An exclusively locked
68  * vnode is returned.
69  */
70 int
71 hammer_vfs_vget(struct mount *mp, ino_t ino, struct vnode **vpp)
72 {
73         struct hammer_mount *hmp = (void *)mp->mnt_data;
74         struct hammer_inode *ip;
75         int error;
76
77         /*
78          * Get/allocate the hammer_inode structure.  The structure must be
79          * unlocked while we manipulate the related vnode to avoid a
80          * deadlock.
81          */
82         ip = hammer_get_inode(hmp, ino, &error);
83         if (ip == NULL) {
84                 *vpp = NULL;
85                 return(error);
86         }
87         error = hammer_get_vnode(ip, LK_EXCLUSIVE, vpp);
88         hammer_rel_inode(ip, 0);
89         return (error);
90 }
91
92 /*
93  * Return a locked vnode for the specified inode.  The inode must be
94  * referenced but NOT LOCKED on entry and will remain referenced on
95  * return.
96  */
97 int
98 hammer_get_vnode(struct hammer_inode *ip, int lktype, struct vnode **vpp)
99 {
100         struct vnode *vp;
101         int error = 0;
102
103         for (;;) {
104                 if ((vp = ip->vp) == NULL) {
105                         error = getnewvnode(VT_HAMMER, ip->hmp->mp, vpp, 0, 0);
106                         if (error)
107                                 break;
108                         hammer_lock_ex(&ip->lock);
109                         if (ip->vp != NULL) {
110                                 hammer_unlock(&ip->lock);
111                                 vp->v_type = VBAD;
112                                 vx_put(vp);
113                                 continue;
114                         }
115                         hammer_ref(&ip->lock);
116                         vp = *vpp;
117                         ip->vp = vp;
118                         vp->v_type = hammer_get_vnode_type(
119                                             ip->ino_rec.base.base.obj_type);
120                         vp->v_data = (void *)ip;
121                         /* vnode locked by getnewvnode() */
122                         /* make related vnode dirty if inode dirty? */
123                         hammer_unlock(&ip->lock);
124                         if (vp->v_type == VREG)
125                                 vinitvmio(vp, ip->ino_rec.ino_size);
126                         break;
127                 }
128
129                 /*
130                  * loop if the vget fails (aka races), or if the vp
131                  * no longer matches ip->vp.
132                  */
133                 if (vget(vp, LK_EXCLUSIVE) == 0) {
134                         if (vp == ip->vp)
135                                 break;
136                         vput(vp);
137                 }
138         }
139         *vpp = vp;
140         return(error);
141 }
142
143 /*
144  * Acquire a HAMMER inode.  The returned inode is not locked.  These functions
145  * do not attach or detach the related vnode (use hammer_get_vnode() for
146  * that).
147  */
148 struct hammer_inode *
149 hammer_get_inode(struct hammer_mount *hmp, u_int64_t obj_id, int *errorp)
150 {
151         struct hammer_inode_info iinfo;
152         struct hammer_cursor cursor;
153         struct hammer_inode *ip;
154
155         /*
156          * Determine if we already have an inode cached.  If we do then
157          * we are golden.
158          */
159         iinfo.obj_id = obj_id;
160         iinfo.obj_asof = HAMMER_MAX_TID;        /* XXX */
161 loop:
162         ip = hammer_ino_rb_tree_RB_LOOKUP_INFO(&hmp->rb_inos_root, &iinfo);
163         if (ip) {
164                 hammer_ref(&ip->lock);
165                 *errorp = 0;
166                 return(ip);
167         }
168
169         ip = kmalloc(sizeof(*ip), M_HAMMER, M_WAITOK|M_ZERO);
170         ip->obj_id = obj_id;
171         ip->obj_asof = iinfo.obj_asof;
172         ip->hmp = hmp;
173         RB_INIT(&ip->rec_tree);
174
175         /*
176          * Locate the on-disk inode.
177          * If we do not have an inode cached search the HAMMER on-disk B-Tree
178          * for it.
179          */
180
181         hammer_init_cursor_hmp(&cursor, hmp);
182         cursor.key_beg.obj_id = ip->obj_id;
183         cursor.key_beg.key = 0;
184         cursor.key_beg.create_tid = iinfo.obj_asof;
185         cursor.key_beg.delete_tid = 0;
186         cursor.key_beg.rec_type = HAMMER_RECTYPE_INODE;
187         cursor.key_beg.obj_type = 0;
188         cursor.flags = HAMMER_CURSOR_GET_RECORD | HAMMER_CURSOR_GET_DATA;
189
190         *errorp = hammer_btree_lookup(&cursor);
191
192         /*
193          * On success the B-Tree lookup will hold the appropriate
194          * buffer cache buffers and provide a pointer to the requested
195          * information.  Copy the information to the in-memory inode.
196          */
197         if (*errorp == 0) {
198                 ip->ino_rec = cursor.record->inode;
199                 ip->ino_data = cursor.data->inode;
200         }
201         hammer_cache_node(cursor.node, &ip->cache);
202         hammer_done_cursor(&cursor);
203
204         /*
205          * On success load the inode's record and data and insert the
206          * inode into the B-Tree.  It is possible to race another lookup
207          * insertion of the same inode so deal with that condition too.
208          */
209         if (*errorp == 0) {
210                 hammer_ref(&ip->lock);
211                 if (RB_INSERT(hammer_ino_rb_tree, &hmp->rb_inos_root, ip)) {
212                         hammer_uncache_node(&ip->cache);
213                         hammer_unref(&ip->lock);
214                         kfree(ip, M_HAMMER);
215                         goto loop;
216                 }
217         } else {
218                 kfree(ip, M_HAMMER);
219                 ip = NULL;
220         }
221         return (ip);
222 }
223
224 /*
225  * Create a new filesystem object, returning the inode in *ipp.  The
226  * returned inode will be referenced but not locked.
227  *
228  * The inode is created in-memory and will be delay-synchronized to the
229  * disk.
230  */
231 int
232 hammer_create_inode(hammer_transaction_t trans, struct vattr *vap,
233                     struct ucred *cred, hammer_inode_t dip,
234                     struct hammer_inode **ipp)
235 {
236         hammer_mount_t hmp;
237         hammer_inode_t ip;
238         uid_t xuid;
239
240         hmp = trans->hmp;
241         ip = kmalloc(sizeof(*ip), M_HAMMER, M_WAITOK|M_ZERO);
242         ip->obj_id = hammer_alloc_tid(trans);
243         KKASSERT(ip->obj_id != 0);
244         ip->obj_asof = HAMMER_MAX_TID;  /* XXX */
245         ip->hmp = hmp;
246         ip->flags = HAMMER_INODE_DDIRTY | HAMMER_INODE_RDIRTY |
247                     HAMMER_INODE_ITIMES;
248         ip->last_tid = trans->tid;
249
250         RB_INIT(&ip->rec_tree);
251
252         ip->ino_rec.ino_atime = trans->tid;
253         ip->ino_rec.ino_mtime = trans->tid;
254         ip->ino_rec.ino_size = 0;
255         ip->ino_rec.ino_nlinks = 0;
256         /* XXX */
257         kprintf("rootvol %p ondisk %p\n", hmp->rootvol, hmp->rootvol->ondisk);
258         ip->ino_rec.base.rec_id = hammer_alloc_recid(trans);
259         KKASSERT(ip->ino_rec.base.rec_id != 0);
260         ip->ino_rec.base.base.obj_id = ip->obj_id;
261         ip->ino_rec.base.base.key = 0;
262         ip->ino_rec.base.base.create_tid = trans->tid;
263         ip->ino_rec.base.base.delete_tid = 0;
264         ip->ino_rec.base.base.rec_type = HAMMER_RECTYPE_INODE;
265         ip->ino_rec.base.base.obj_type = hammer_get_obj_type(vap->va_type);
266
267         ip->ino_data.version = HAMMER_INODE_DATA_VERSION;
268         ip->ino_data.mode = vap->va_mode;
269         ip->ino_data.ctime = trans->tid;
270         ip->ino_data.parent_obj_id = (dip) ? dip->ino_rec.base.base.obj_id : 0;
271
272         /*
273          * Calculate default uid/gid and overwrite with information from
274          * the vap.
275          */
276         xuid = hammer_to_unix_xid(&dip->ino_data.uid);
277         ip->ino_data.gid = dip->ino_data.gid;
278         xuid = vop_helper_create_uid(hmp->mp, dip->ino_data.mode, xuid, cred,
279                                      &vap->va_mode);
280         ip->ino_data.mode = vap->va_mode;
281
282         if (vap->va_vaflags & VA_UID_UUID_VALID)
283                 ip->ino_data.uid = vap->va_uid_uuid;
284         else if (vap->va_uid != (uid_t)VNOVAL)
285                 hammer_guid_to_uuid(&ip->ino_data.uid, xuid);
286         if (vap->va_vaflags & VA_GID_UUID_VALID)
287                 ip->ino_data.gid = vap->va_gid_uuid;
288         else if (vap->va_gid != (gid_t)VNOVAL)
289                 hammer_guid_to_uuid(&ip->ino_data.gid, vap->va_gid);
290
291         hammer_ref(&ip->lock);
292         if (RB_INSERT(hammer_ino_rb_tree, &hmp->rb_inos_root, ip)) {
293                 hammer_unref(&ip->lock);
294                 panic("hammer_create_inode: duplicate obj_id %llx", ip->obj_id);
295         }
296         *ipp = ip;
297         return(0);
298 }
299
300 /*
301  * Release a reference on an inode and unload it if told to flush.
302  */
303 void
304 hammer_rel_inode(struct hammer_inode *ip, int flush)
305 {
306         hammer_unref(&ip->lock);
307         if (flush || ip->ino_rec.ino_nlinks == 0)
308                 ip->flags |= HAMMER_INODE_FLUSH;
309         if (ip->lock.refs == 0 && (ip->flags & HAMMER_INODE_FLUSH))
310                 hammer_unload_inode(ip, NULL);
311 }
312
313 /*
314  * Unload and destroy the specified inode.
315  *
316  * (called via RB_SCAN)
317  */
318 int
319 hammer_unload_inode(struct hammer_inode *ip, void *data __unused)
320 {
321         KASSERT(ip->lock.refs == 0,
322                 ("hammer_unload_inode: %d refs\n", ip->lock.refs));
323         KKASSERT(ip->vp == NULL);
324         hammer_ref(&ip->lock);
325
326         /* XXX flush inode to disk */
327         kprintf("flush inode %p\n", ip);
328
329         RB_REMOVE(hammer_ino_rb_tree, &ip->hmp->rb_inos_root, ip);
330
331         hammer_uncache_node(&ip->cache);
332         kfree(ip, M_HAMMER);
333         return(0);
334 }
335
336 /*
337  * A transaction has modified an inode, requiring a new record and possibly
338  * also data to be written out.
339  */
340 void
341 hammer_modify_inode(struct hammer_transaction *trans,
342                     struct hammer_inode *ip, int flags)
343 {
344         ip->flags |= flags;
345         ip->last_tid = trans->tid;
346 }
347
348 /*
349  * Access the filesystem buffer containing the cluster-relative byte
350  * offset, validate the buffer type, load *bufferp and return a
351  * pointer to the requested data.  The buffer is reference and locked on
352  * return.
353  *
354  * If buf_type is 0 the buffer is assumed to be a pure-data buffer and
355  * no type or crc check is performed.
356  *
357  * If *bufferp is not NULL on entry it is assumed to contain a locked
358  * and referenced buffer which will then be replaced.
359  *
360  * If the caller is holding another unrelated buffer locked it must be
361  * passed in reorderbuf so we can properly order buffer locks.
362  *
363  * XXX add a flag for the buffer type and check the CRC here XXX
364  */
365 void *
366 hammer_bread(hammer_cluster_t cluster, int32_t cloff,
367              u_int64_t buf_type, int *errorp,
368              struct hammer_buffer **bufferp)
369 {
370         hammer_buffer_t buffer;
371         int32_t buf_no;
372         int32_t buf_off;
373
374         /*
375          * Load the correct filesystem buffer, replacing *bufferp.
376          */
377         buf_no = cloff / HAMMER_BUFSIZE;
378         buffer = *bufferp;
379         if (buffer == NULL || buffer->cluster != cluster ||
380             buffer->buf_no != buf_no) {
381                 if (buffer) {
382                         hammer_unlock(&buffer->io.lock);
383                         hammer_rel_buffer(buffer, 0);
384                 }
385                 buffer = hammer_get_buffer(cluster, buf_no, 0, errorp);
386                 *bufferp = buffer;
387                 if (buffer == NULL)
388                         return(NULL);
389                 hammer_lock_ex(&buffer->io.lock);
390         }
391
392         /*
393          * Validate the buffer type
394          */
395         buf_off = cloff & HAMMER_BUFMASK;
396         if (buf_type) {
397                 if (buf_type != buffer->ondisk->head.buf_type) {
398                         kprintf("BUFFER HEAD TYPE MISMATCH %llx %llx\n",
399                                 buf_type, buffer->ondisk->head.buf_type);
400                         *errorp = EIO;
401                         return(NULL);
402                 }
403                 if (buf_off < sizeof(buffer->ondisk->head)) {
404                         kprintf("BUFFER OFFSET TOO LOW %d\n", buf_off);
405                         *errorp = EIO;
406                         return(NULL);
407                 }
408         }
409
410         /*
411          * Return a pointer to the buffer data.
412          */
413         *errorp = 0;
414         return((char *)buffer->ondisk + buf_off);
415 }
416