2 * Copyright (c) 2007 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
34 * $DragonFly: src/sys/vfs/hammer/hammer_inode.c,v 1.27 2008/02/05 20:52:01 dillon Exp $
42 * The kernel is not actively referencing this vnode but is still holding
46 hammer_vop_inactive(struct vop_inactive_args
*ap
)
48 struct hammer_inode
*ip
= VTOI(ap
->a_vp
);
59 * If the inode no longer has any references we recover its
60 * in-memory resources immediately.
62 if (ip
->ino_rec
.ino_nlinks
== 0)
68 * Release the vnode association. This is typically (but not always)
69 * the last reference on the inode and will flush the inode to the
72 * XXX Currently our sync code only runs through inodes with vnode
73 * associations, so we depend on hammer_rel_inode() to sync any inode
74 * record data to the block device prior to losing the association.
75 * Otherwise transactions that the user expected to be distinct by
76 * doing a manual sync may be merged.
79 hammer_vop_reclaim(struct vop_reclaim_args
*ap
)
81 struct hammer_inode
*ip
;
86 if ((ip
= vp
->v_data
) != NULL
) {
89 hammer_rel_inode(ip
, 0);
95 * Return a locked vnode for the specified inode. The inode must be
96 * referenced but NOT LOCKED on entry and will remain referenced on
100 hammer_get_vnode(struct hammer_inode
*ip
, int lktype
, struct vnode
**vpp
)
106 if ((vp
= ip
->vp
) == NULL
) {
107 error
= getnewvnode(VT_HAMMER
, ip
->hmp
->mp
, vpp
, 0, 0);
110 hammer_lock_ex(&ip
->lock
);
111 if (ip
->vp
!= NULL
) {
112 hammer_unlock(&ip
->lock
);
117 hammer_ref(&ip
->lock
);
120 vp
->v_type
= hammer_get_vnode_type(
121 ip
->ino_rec
.base
.base
.obj_type
);
123 switch(ip
->ino_rec
.base
.base
.obj_type
) {
124 case HAMMER_OBJTYPE_CDEV
:
125 case HAMMER_OBJTYPE_BDEV
:
126 vp
->v_ops
= &ip
->hmp
->mp
->mnt_vn_spec_ops
;
127 addaliasu(vp
, ip
->ino_data
.rmajor
,
128 ip
->ino_data
.rminor
);
130 case HAMMER_OBJTYPE_FIFO
:
131 vp
->v_ops
= &ip
->hmp
->mp
->mnt_vn_fifo_ops
;
136 if (ip
->obj_id
== HAMMER_OBJID_ROOT
)
139 vp
->v_data
= (void *)ip
;
140 /* vnode locked by getnewvnode() */
141 /* make related vnode dirty if inode dirty? */
142 hammer_unlock(&ip
->lock
);
143 if (vp
->v_type
== VREG
)
144 vinitvmio(vp
, ip
->ino_rec
.ino_size
);
149 * loop if the vget fails (aka races), or if the vp
150 * no longer matches ip->vp.
152 if (vget(vp
, LK_EXCLUSIVE
) == 0) {
163 * Acquire a HAMMER inode. The returned inode is not locked. These functions
164 * do not attach or detach the related vnode (use hammer_get_vnode() for
167 * The flags argument is only applied for newly created inodes, and only
168 * certain flags are inherited.
170 struct hammer_inode
*
171 hammer_get_inode(struct hammer_mount
*hmp
, struct hammer_node
**cache
,
172 u_int64_t obj_id
, hammer_tid_t asof
, int flags
, int *errorp
)
174 struct hammer_inode_info iinfo
;
175 struct hammer_cursor cursor
;
176 struct hammer_inode
*ip
;
179 * Determine if we already have an inode cached. If we do then
182 iinfo
.obj_id
= obj_id
;
183 iinfo
.obj_asof
= asof
;
185 ip
= hammer_ino_rb_tree_RB_LOOKUP_INFO(&hmp
->rb_inos_root
, &iinfo
);
187 hammer_ref(&ip
->lock
);
192 ip
= kmalloc(sizeof(*ip
), M_HAMMER
, M_WAITOK
|M_ZERO
);
193 ++hammer_count_inodes
;
195 ip
->obj_asof
= iinfo
.obj_asof
;
197 ip
->flags
= flags
& HAMMER_INODE_RO
;
199 ip
->flags
|= HAMMER_INODE_RO
;
200 RB_INIT(&ip
->rec_tree
);
203 * Locate the on-disk inode.
206 hammer_init_cursor_hmp(&cursor
, cache
, hmp
);
207 cursor
.key_beg
.obj_id
= ip
->obj_id
;
208 cursor
.key_beg
.key
= 0;
209 cursor
.key_beg
.create_tid
= 0;
210 cursor
.key_beg
.delete_tid
= 0;
211 cursor
.key_beg
.rec_type
= HAMMER_RECTYPE_INODE
;
212 cursor
.key_beg
.obj_type
= 0;
213 cursor
.asof
= iinfo
.obj_asof
;
214 cursor
.flags
= HAMMER_CURSOR_GET_RECORD
| HAMMER_CURSOR_GET_DATA
|
217 *errorp
= hammer_btree_lookup(&cursor
);
218 if (*errorp
== EDEADLK
) {
219 hammer_done_cursor(&cursor
);
224 * On success the B-Tree lookup will hold the appropriate
225 * buffer cache buffers and provide a pointer to the requested
226 * information. Copy the information to the in-memory inode
227 * and cache the B-Tree node to improve future operations.
230 ip
->ino_rec
= cursor
.record
->inode
;
231 ip
->ino_data
= cursor
.data
->inode
;
232 hammer_cache_node(cursor
.node
, &ip
->cache
[0]);
234 hammer_cache_node(cursor
.node
, cache
);
238 * On success load the inode's record and data and insert the
239 * inode into the B-Tree. It is possible to race another lookup
240 * insertion of the same inode so deal with that condition too.
242 * The cursor's locked node interlocks against others creating and
243 * destroying ip while we were blocked.
246 hammer_ref(&ip
->lock
);
247 if (RB_INSERT(hammer_ino_rb_tree
, &hmp
->rb_inos_root
, ip
)) {
248 hammer_uncache_node(&ip
->cache
[0]);
249 hammer_uncache_node(&ip
->cache
[1]);
250 hammer_unref(&ip
->lock
);
251 --hammer_count_inodes
;
253 hammer_done_cursor(&cursor
);
256 ip
->flags
|= HAMMER_INODE_ONDISK
;
258 --hammer_count_inodes
;
262 hammer_done_cursor(&cursor
);
267 * Create a new filesystem object, returning the inode in *ipp. The
268 * returned inode will be referenced but not locked.
270 * The inode is created in-memory and will be delay-synchronized to the
274 hammer_create_inode(hammer_transaction_t trans
, struct vattr
*vap
,
275 struct ucred
*cred
, hammer_inode_t dip
,
276 struct hammer_inode
**ipp
)
283 ip
= kmalloc(sizeof(*ip
), M_HAMMER
, M_WAITOK
|M_ZERO
);
284 ++hammer_count_inodes
;
285 ip
->obj_id
= hammer_alloc_tid(trans
);
286 KKASSERT(ip
->obj_id
!= 0);
287 ip
->obj_asof
= hmp
->asof
;
289 ip
->flags
= HAMMER_INODE_DDIRTY
| HAMMER_INODE_RDIRTY
|
291 ip
->last_tid
= trans
->tid
;
293 RB_INIT(&ip
->rec_tree
);
295 ip
->ino_rec
.ino_atime
= trans
->tid
;
296 ip
->ino_rec
.ino_mtime
= trans
->tid
;
297 ip
->ino_rec
.ino_size
= 0;
298 ip
->ino_rec
.ino_nlinks
= 0;
300 ip
->ino_rec
.base
.base
.btype
= HAMMER_BTREE_TYPE_RECORD
;
301 ip
->ino_rec
.base
.base
.obj_id
= ip
->obj_id
;
302 ip
->ino_rec
.base
.base
.key
= 0;
303 ip
->ino_rec
.base
.base
.create_tid
= trans
->tid
;
304 ip
->ino_rec
.base
.base
.delete_tid
= 0;
305 ip
->ino_rec
.base
.base
.rec_type
= HAMMER_RECTYPE_INODE
;
306 ip
->ino_rec
.base
.base
.obj_type
= hammer_get_obj_type(vap
->va_type
);
308 ip
->ino_data
.version
= HAMMER_INODE_DATA_VERSION
;
309 ip
->ino_data
.mode
= vap
->va_mode
;
310 ip
->ino_data
.ctime
= trans
->tid
;
311 ip
->ino_data
.parent_obj_id
= (dip
) ? dip
->ino_rec
.base
.base
.obj_id
: 0;
313 switch(ip
->ino_rec
.base
.base
.obj_type
) {
314 case HAMMER_OBJTYPE_CDEV
:
315 case HAMMER_OBJTYPE_BDEV
:
316 ip
->ino_data
.rmajor
= vap
->va_rmajor
;
317 ip
->ino_data
.rminor
= vap
->va_rminor
;
324 * Calculate default uid/gid and overwrite with information from
327 xuid
= hammer_to_unix_xid(&dip
->ino_data
.uid
);
328 ip
->ino_data
.gid
= dip
->ino_data
.gid
;
329 xuid
= vop_helper_create_uid(hmp
->mp
, dip
->ino_data
.mode
, xuid
, cred
,
331 ip
->ino_data
.mode
= vap
->va_mode
;
333 if (vap
->va_vaflags
& VA_UID_UUID_VALID
)
334 ip
->ino_data
.uid
= vap
->va_uid_uuid
;
335 else if (vap
->va_uid
!= (uid_t
)VNOVAL
)
336 hammer_guid_to_uuid(&ip
->ino_data
.uid
, xuid
);
337 if (vap
->va_vaflags
& VA_GID_UUID_VALID
)
338 ip
->ino_data
.gid
= vap
->va_gid_uuid
;
339 else if (vap
->va_gid
!= (gid_t
)VNOVAL
)
340 hammer_guid_to_uuid(&ip
->ino_data
.gid
, vap
->va_gid
);
342 hammer_ref(&ip
->lock
);
343 if (RB_INSERT(hammer_ino_rb_tree
, &hmp
->rb_inos_root
, ip
)) {
344 hammer_unref(&ip
->lock
);
345 panic("hammer_create_inode: duplicate obj_id %llx", ip
->obj_id
);
352 * Called by hammer_sync_inode().
355 hammer_update_inode(hammer_inode_t ip
)
357 struct hammer_cursor cursor
;
358 struct hammer_cursor
*spike
= NULL
;
359 hammer_record_t record
;
361 hammer_tid_t last_tid
;
364 * Locate the record on-disk and mark it as deleted. Both the B-Tree
365 * node and the record must be marked deleted. The record may or
366 * may not be physically deleted, depending on the retention policy.
368 * If the inode has already been deleted on-disk we have nothing
371 * XXX Update the inode record and data in-place if the retention
374 last_tid
= ip
->last_tid
;
378 if ((ip
->flags
& (HAMMER_INODE_ONDISK
|HAMMER_INODE_DELONDISK
)) ==
379 HAMMER_INODE_ONDISK
) {
380 hammer_init_cursor_hmp(&cursor
, &ip
->cache
[0], ip
->hmp
);
381 cursor
.key_beg
.obj_id
= ip
->obj_id
;
382 cursor
.key_beg
.key
= 0;
383 cursor
.key_beg
.create_tid
= 0;
384 cursor
.key_beg
.delete_tid
= 0;
385 cursor
.key_beg
.rec_type
= HAMMER_RECTYPE_INODE
;
386 cursor
.key_beg
.obj_type
= 0;
387 cursor
.asof
= ip
->obj_asof
;
388 cursor
.flags
|= HAMMER_CURSOR_GET_RECORD
| HAMMER_CURSOR_ASOF
;
390 error
= hammer_btree_lookup(&cursor
);
393 error
= hammer_ip_delete_record(&cursor
, last_tid
);
395 ip
->flags
|= HAMMER_INODE_DELONDISK
;
396 hammer_cache_node(cursor
.node
, &ip
->cache
[0]);
398 hammer_done_cursor(&cursor
);
399 if (error
== EDEADLK
)
404 * Write out a new record if the in-memory inode is not marked
405 * as having been deleted. Update our inode statistics if this
406 * is the first application of the inode on-disk.
408 * If the inode has been deleted permanently, HAMMER_INODE_DELONDISK
409 * will remain set and prevent further updates.
411 if (error
== 0 && (ip
->flags
& HAMMER_INODE_DELETED
) == 0) {
412 record
= hammer_alloc_mem_record(ip
);
413 record
->rec
.inode
= ip
->ino_rec
;
414 record
->rec
.inode
.base
.base
.create_tid
= last_tid
;
415 record
->rec
.inode
.base
.data_len
= sizeof(ip
->ino_data
);
416 record
->data
= (void *)&ip
->ino_data
;
417 error
= hammer_ip_sync_record(record
, &spike
);
418 record
->flags
|= HAMMER_RECF_DELETED
;
419 hammer_rel_mem_record(record
);
420 if (error
== ENOSPC
) {
421 error
= hammer_spike(&spike
);
425 KKASSERT(spike
== NULL
);
427 ip
->flags
&= ~(HAMMER_INODE_RDIRTY
|
428 HAMMER_INODE_DDIRTY
|
429 HAMMER_INODE_DELONDISK
|
430 HAMMER_INODE_ITIMES
);
431 if ((ip
->flags
& HAMMER_INODE_ONDISK
) == 0) {
432 hammer_modify_volume(ip
->hmp
->rootvol
);
433 ++ip
->hmp
->rootvol
->ondisk
->vol0_stat_inodes
;
434 ip
->flags
|= HAMMER_INODE_ONDISK
;
442 * Update only the itimes fields. This is done no-historically. The
443 * record is updated in-place on the disk.
446 hammer_update_itimes(hammer_inode_t ip
)
448 struct hammer_cursor cursor
;
449 struct hammer_inode_record
*rec
;
454 if ((ip
->flags
& (HAMMER_INODE_ONDISK
|HAMMER_INODE_DELONDISK
)) ==
455 HAMMER_INODE_ONDISK
) {
456 hammer_init_cursor_hmp(&cursor
, &ip
->cache
[0], ip
->hmp
);
457 cursor
.key_beg
.obj_id
= ip
->obj_id
;
458 cursor
.key_beg
.key
= 0;
459 cursor
.key_beg
.create_tid
= 0;
460 cursor
.key_beg
.delete_tid
= 0;
461 cursor
.key_beg
.rec_type
= HAMMER_RECTYPE_INODE
;
462 cursor
.key_beg
.obj_type
= 0;
463 cursor
.asof
= ip
->obj_asof
;
464 cursor
.flags
|= HAMMER_CURSOR_GET_RECORD
| HAMMER_CURSOR_ASOF
;
466 error
= hammer_btree_lookup(&cursor
);
468 rec
= &cursor
.record
->inode
;
469 hammer_modify_buffer_nodep(cursor
.record_buffer
);
470 rec
->ino_atime
= ip
->ino_rec
.ino_atime
;
471 rec
->ino_mtime
= ip
->ino_rec
.ino_mtime
;
472 ip
->flags
&= ~HAMMER_INODE_ITIMES
;
473 /* XXX recalculate crc */
474 hammer_cache_node(cursor
.node
, &ip
->cache
[0]);
476 hammer_done_cursor(&cursor
);
477 if (error
== EDEADLK
)
484 * Release a reference on an inode. If asked to flush the last release
485 * will flush the inode.
488 hammer_rel_inode(struct hammer_inode
*ip
, int flush
)
490 hammer_unref(&ip
->lock
);
492 ip
->flags
|= HAMMER_INODE_FLUSH
;
493 if (ip
->lock
.refs
== 0) {
494 if (ip
->flags
& HAMMER_INODE_FLUSH
)
495 hammer_unload_inode(ip
, (void *)MNT_WAIT
);
497 hammer_unload_inode(ip
, (void *)MNT_NOWAIT
);
502 * Unload and destroy the specified inode.
504 * (typically called via RB_SCAN)
507 hammer_unload_inode(struct hammer_inode
*ip
, void *data
)
511 KASSERT(ip
->lock
.refs
== 0,
512 ("hammer_unload_inode: %d refs\n", ip
->lock
.refs
));
513 KKASSERT(ip
->vp
== NULL
);
514 hammer_ref(&ip
->lock
);
516 error
= hammer_sync_inode(ip
, (int)data
, 1);
518 kprintf("hammer_sync_inode failed error %d\n", error
);
519 if (ip
->lock
.refs
== 1) {
520 KKASSERT(RB_EMPTY(&ip
->rec_tree
));
521 RB_REMOVE(hammer_ino_rb_tree
, &ip
->hmp
->rb_inos_root
, ip
);
523 hammer_uncache_node(&ip
->cache
[0]);
524 hammer_uncache_node(&ip
->cache
[1]);
525 --hammer_count_inodes
;
528 hammer_unref(&ip
->lock
);
534 * A transaction has modified an inode, requiring updates as specified by
537 * HAMMER_INODE_RDIRTY: Inode record has been updated
538 * HAMMER_INODE_DDIRTY: Inode data has been updated
539 * HAMMER_INODE_DELETED: Inode record/data must be deleted
540 * HAMMER_INODE_ITIMES: mtime/atime has been updated
542 * last_tid is the TID to use to generate the correct TID when the inode
543 * is synced to disk. The first inode record laid out on disk must match
544 * the transaction id of the related directory entry so only update last_tid
545 * if that has already occured.
548 hammer_modify_inode(struct hammer_transaction
*trans
,
549 struct hammer_inode
*ip
, int flags
)
551 KKASSERT ((ip
->flags
& HAMMER_INODE_RO
) == 0 ||
552 (HAMMER_INODE_RDIRTY
|HAMMER_INODE_DDIRTY
|
553 HAMMER_INODE_DELETED
|HAMMER_INODE_ITIMES
) == 0);
556 (HAMMER_INODE_RDIRTY
|HAMMER_INODE_DDIRTY
|HAMMER_INODE_DELETED
)) {
557 if (hammer_debug_tid
) {
558 kprintf("hammer_modify_inode: %016llx (%08x)\n",
559 trans
->tid
, (int)(trans
->tid
/ 1000000000LL));
561 if (ip
->flags
& HAMMER_INODE_ONDISK
)
562 ip
->last_tid
= trans
->tid
;
568 * Sync any dirty buffers and records associated with an inode. The
569 * inode's last_tid field is used as the transaction id for the sync,
570 * overriding any intermediate TIDs that were used for records. Note
571 * that the dirty buffer cache buffers do not have any knowledge of
572 * the transaction id they were modified under.
574 * If we can't sync due to a cluster becoming full the spike structure
575 * will be filled in and ENOSPC returned. We must return -ENOSPC to
576 * terminate the RB_SCAN.
579 hammer_sync_inode_callback(hammer_record_t rec
, void *data
)
581 struct hammer_cursor
**spike
= data
;
584 hammer_ref(&rec
->lock
);
585 error
= hammer_ip_sync_record(rec
, spike
);
586 hammer_rel_mem_record(rec
);
590 if (error
!= -ENOSPC
) {
591 kprintf("hammer_sync_inode_callback: sync failed rec "
592 "%p, error %d\n", rec
, error
);
602 hammer_sync_inode(hammer_inode_t ip
, int waitfor
, int handle_delete
)
604 struct hammer_transaction trans
;
605 struct hammer_cursor
*spike
= NULL
;
608 if ((ip
->flags
& HAMMER_INODE_MODMASK
) == 0) {
612 hammer_lock_ex(&ip
->lock
);
615 * Use the transaction id of the last operation to sync.
618 hammer_start_transaction_tid(&trans
, ip
->hmp
, ip
->last_tid
);
620 hammer_start_transaction(&trans
, ip
->hmp
);
623 * If the inode has been deleted (nlinks == 0), and the OS no longer
624 * has any references to it (handle_delete != 0), clean up in-memory
627 * NOTE: We do not set the RDIRTY flag when updating the delete_tid,
628 * setting HAMMER_INODE_DELETED takes care of it.
630 * NOTE: Because we may sync records within this new transaction,
631 * force the inode update later on to use our transaction id or
632 * the delete_tid of the inode may be less then the create_tid of
633 * the inode update. XXX shouldn't happen but don't take the chance.
635 * NOTE: The call to hammer_ip_delete_range() cannot return ENOSPC
636 * so we can pass a NULL spike structure, because no partial data
637 * deletion can occur (yet).
639 if (ip
->ino_rec
.ino_nlinks
== 0 && handle_delete
&&
640 (ip
->flags
& HAMMER_INODE_GONE
) == 0) {
641 ip
->flags
|= HAMMER_INODE_GONE
;
643 vtruncbuf(ip
->vp
, 0, HAMMER_BUFSIZE
);
644 error
= hammer_ip_delete_range_all(&trans
, ip
);
645 KKASSERT(RB_EMPTY(&ip
->rec_tree
));
646 ip
->ino_rec
.base
.base
.delete_tid
= trans
.tid
;
647 hammer_modify_inode(&trans
, ip
, HAMMER_INODE_DELETED
);
648 hammer_modify_volume(ip
->hmp
->rootvol
);
649 --ip
->hmp
->rootvol
->ondisk
->vol0_stat_inodes
;
653 * Sync the buffer cache.
655 if (ip
->vp
!= NULL
) {
656 error
= vfsync(ip
->vp
, waitfor
, 1, NULL
, NULL
);
657 if (RB_ROOT(&ip
->vp
->v_rbdirty_tree
) == NULL
)
658 ip
->flags
&= ~HAMMER_INODE_BUFS
;
665 * Now sync related records
668 error
= RB_SCAN(hammer_rec_rb_tree
, &ip
->rec_tree
, NULL
,
669 hammer_sync_inode_callback
, &spike
);
670 KKASSERT(error
<= 0);
673 if (error
== ENOSPC
) {
674 error
= hammer_spike(&spike
);
680 if (RB_EMPTY(&ip
->rec_tree
))
681 ip
->flags
&= ~HAMMER_INODE_XDIRTY
;
684 * Now update the inode's on-disk inode-data and/or on-disk record.
686 switch(ip
->flags
& (HAMMER_INODE_DELETED
|HAMMER_INODE_ONDISK
)) {
687 case HAMMER_INODE_DELETED
|HAMMER_INODE_ONDISK
:
689 * If deleted and on-disk, don't set any additional flags.
690 * the delete flag takes care of things.
693 case HAMMER_INODE_DELETED
:
695 * Take care of the case where a deleted inode was never
696 * flushed to the disk in the first place.
698 ip
->flags
&= ~(HAMMER_INODE_RDIRTY
|HAMMER_INODE_DDIRTY
|
699 HAMMER_INODE_XDIRTY
|HAMMER_INODE_ITIMES
);
700 while (RB_ROOT(&ip
->rec_tree
)) {
701 hammer_record_t rec
= RB_ROOT(&ip
->rec_tree
);
702 hammer_ref(&rec
->lock
);
703 rec
->flags
|= HAMMER_RECF_DELETED
;
704 hammer_rel_mem_record(rec
);
707 case HAMMER_INODE_ONDISK
:
709 * If already on-disk, do not set any additional flags.
714 * If not on-disk and not deleted, set both dirty flags
715 * to force an initial record to be written.
717 ip
->flags
|= HAMMER_INODE_RDIRTY
| HAMMER_INODE_DDIRTY
;
722 * If RDIRTY or DDIRTY is set, write out a new record. If the inode
723 * is already on-disk the old record is marked as deleted.
725 * If DELETED is set hammer_update_inode() will delete the existing
726 * record without writing out a new one.
728 * If *ONLY* the ITIMES flag is set we can update the record in-place.
730 if ((ip
->flags
& (HAMMER_INODE_RDIRTY
| HAMMER_INODE_DDIRTY
|
731 HAMMER_INODE_ITIMES
| HAMMER_INODE_DELETED
)) ==
732 HAMMER_INODE_ITIMES
) {
733 error
= hammer_update_itimes(ip
);
735 if (ip
->flags
& (HAMMER_INODE_RDIRTY
| HAMMER_INODE_DDIRTY
|
736 HAMMER_INODE_ITIMES
| HAMMER_INODE_DELETED
)) {
737 error
= hammer_update_inode(ip
);
739 hammer_commit_transaction(&trans
);
740 hammer_unlock(&ip
->lock
);
745 * Access the filesystem buffer containing the cluster-relative byte
746 * offset, validate the buffer type, load *bufferp and return a
747 * pointer to the requested data. The buffer is reference and locked on
750 * If buf_type is 0 the buffer is assumed to be a pure-data buffer and
751 * no type or crc check is performed.
753 * If *bufferp is not NULL on entry it is assumed to contain a locked
754 * and referenced buffer which will then be replaced.
756 * If the caller is holding another unrelated buffer locked it must be
757 * passed in reorderbuf so we can properly order buffer locks.
759 * XXX add a flag for the buffer type and check the CRC here XXX
762 hammer_bread(hammer_cluster_t cluster
, int32_t cloff
,
763 u_int64_t buf_type
, int *errorp
,
764 struct hammer_buffer
**bufferp
)
766 hammer_buffer_t buffer
;
771 * Load the correct filesystem buffer, replacing *bufferp.
773 buf_no
= cloff
/ HAMMER_BUFSIZE
;
775 if (buffer
== NULL
|| buffer
->cluster
!= cluster
||
776 buffer
->buf_no
!= buf_no
) {
778 /*hammer_unlock(&buffer->io.lock);*/
779 hammer_rel_buffer(buffer
, 0);
781 buffer
= hammer_get_buffer(cluster
, buf_no
, 0, errorp
);
785 /*hammer_lock_ex(&buffer->io.lock);*/
789 * Validate the buffer type
791 buf_off
= cloff
& HAMMER_BUFMASK
;
793 if (buf_type
!= buffer
->ondisk
->head
.buf_type
) {
794 kprintf("BUFFER HEAD TYPE MISMATCH %llx %llx\n",
795 buf_type
, buffer
->ondisk
->head
.buf_type
);
800 if (buf_off
< sizeof(buffer
->ondisk
->head
)) {
801 kprintf("BUFFER OFFSET TOO LOW %d\n", buf_off
);
809 * Return a pointer to the buffer data.
812 return((char *)buffer
->ondisk
+ buf_off
);