- Fix for possible unset uid/gid in toproto - Fix for default mtree style - Update libelf - Importing libexecinfo - Resynchronize GCC, mpc, gmp, mpfr - build.sh: Replace params with show-params. This has been done as the make target has been renamed in the same way, while a new target named params has been added. This new target generates a file containing all the parameters, instead of printing it on the console. - Update test48 with new etc/services (Fix by Ben Gras <ben@minix3.org) get getservbyport() out of the inner loop Change-Id: Ie6ad5226fa2621ff9f0dee8782ea48f9443d2091
594 lines
17 KiB
C
594 lines
17 KiB
C
/* $NetBSD: chfs_nodeops.c,v 1.3 2012/10/19 12:44:39 ttoth Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2010 Department of Software Engineering,
|
|
* University of Szeged, Hungary
|
|
* Copyright (C) 2010 David Tengeri <dtengeri@inf.u-szeged.hu>
|
|
* Copyright (C) 2010 Tamas Toth <ttoth@inf.u-szeged.hu>
|
|
* Copyright (C) 2010 Adam Hoka <ahoka@NetBSD.org>
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to The NetBSD Foundation
|
|
* by the Department of Software Engineering, University of Szeged, Hungary
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "chfs.h"
|
|
|
|
/*
|
|
* chfs_update_eb_dirty - updates dirty and free space, first and
|
|
* last node references
|
|
* Returns zero in case of success, 1 in case of fail.
|
|
*/
|
|
int
|
|
chfs_update_eb_dirty(struct chfs_mount *chmp,
|
|
struct chfs_eraseblock *cheb, uint32_t size)
|
|
{
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
KASSERT(!mutex_owned(&chmp->chm_lock_sizes));
|
|
|
|
if (!size)
|
|
return 0;
|
|
|
|
if (size > cheb->free_size) {
|
|
chfs_err("free_size (%d) is less then dirty space (%d) "
|
|
"on block (%d)\n", cheb->free_size, size, cheb->lnr);
|
|
return 1;
|
|
}
|
|
mutex_enter(&chmp->chm_lock_sizes);
|
|
chfs_change_size_free(chmp, cheb, -size);
|
|
chfs_change_size_dirty(chmp, cheb, size);
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* chfs_add_node_to_list - adds a data node ref to vnode cache's dnode list
|
|
* This function inserts a data node ref to the list of vnode cache.
|
|
* The list is sorted by data node's lnr and offset.
|
|
*/
|
|
void
|
|
chfs_add_node_to_list(struct chfs_mount *chmp,
|
|
struct chfs_vnode_cache *vc,
|
|
struct chfs_node_ref *new, struct chfs_node_ref **list)
|
|
{
|
|
KASSERT(mutex_owned(&chmp->chm_lock_vnocache));
|
|
|
|
struct chfs_node_ref *nextref = *list;
|
|
struct chfs_node_ref *prevref = NULL;
|
|
|
|
while (nextref && nextref != (struct chfs_node_ref *)vc &&
|
|
(nextref->nref_lnr <= new->nref_lnr)) {
|
|
if (nextref->nref_lnr == new->nref_lnr) {
|
|
while (nextref && nextref !=
|
|
(struct chfs_node_ref *)vc &&
|
|
(CHFS_GET_OFS(nextref->nref_offset) <
|
|
CHFS_GET_OFS(new->nref_offset))) {
|
|
prevref = nextref;
|
|
nextref = nextref->nref_next;
|
|
}
|
|
break;
|
|
}
|
|
prevref = nextref;
|
|
nextref = nextref->nref_next;
|
|
}
|
|
|
|
if (nextref && nextref != (struct chfs_node_ref *)vc &&
|
|
nextref->nref_lnr == new->nref_lnr &&
|
|
CHFS_GET_OFS(nextref->nref_offset) ==
|
|
CHFS_GET_OFS(new->nref_offset)) {
|
|
new->nref_next = nextref->nref_next;
|
|
chfs_mark_node_obsolete(chmp, nextref);
|
|
} else {
|
|
new->nref_next = nextref;
|
|
}
|
|
|
|
KASSERT(new->nref_next != NULL);
|
|
|
|
if (prevref) {
|
|
prevref->nref_next = new;
|
|
} else {
|
|
*list = new;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* chfs_remove_node_from_list - removes a node from a list
|
|
* Usually used for removing data nodes.
|
|
*/
|
|
void
|
|
chfs_remove_node_from_list(struct chfs_mount *chmp,
|
|
struct chfs_vnode_cache *vc,
|
|
struct chfs_node_ref *old_nref, struct chfs_node_ref **list)
|
|
{
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
KASSERT(mutex_owned(&chmp->chm_lock_vnocache));
|
|
|
|
struct chfs_node_ref *tmpnref;
|
|
|
|
if (*list == (struct chfs_node_ref *)vc) {
|
|
/* list is empty */
|
|
return;
|
|
}
|
|
|
|
KASSERT(old_nref->nref_next != NULL);
|
|
|
|
if (*list == old_nref) {
|
|
*list = old_nref->nref_next;
|
|
} else {
|
|
tmpnref = *list;
|
|
while (tmpnref->nref_next &&
|
|
tmpnref->nref_next != (struct chfs_node_ref *)vc) {
|
|
if (tmpnref->nref_next == old_nref) {
|
|
tmpnref->nref_next = old_nref->nref_next;
|
|
break;
|
|
}
|
|
tmpnref = tmpnref->nref_next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* chfs_remove_and_obsolete - removes a node from a list and obsoletes the nref
|
|
* We should use this function carefully on data nodes,
|
|
* because removing a frag will also obsolete the node ref.
|
|
*/
|
|
void
|
|
chfs_remove_and_obsolete(struct chfs_mount *chmp,
|
|
struct chfs_vnode_cache *vc,
|
|
struct chfs_node_ref *old_nref, struct chfs_node_ref **list)
|
|
{
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
KASSERT(mutex_owned(&chmp->chm_lock_vnocache));
|
|
|
|
chfs_remove_node_from_list(chmp, vc, old_nref, list);
|
|
|
|
dbg("[MARK] vno: %llu lnr: %u ofs: %u\n", vc->vno, old_nref->nref_lnr,
|
|
old_nref->nref_offset);
|
|
chfs_mark_node_obsolete(chmp, old_nref);
|
|
}
|
|
|
|
/* chfs_add_fd_to_inode - adds a directory entry to an inode */
|
|
void
|
|
chfs_add_fd_to_inode(struct chfs_mount *chmp,
|
|
struct chfs_inode *parent, struct chfs_dirent *new)
|
|
{
|
|
struct chfs_dirent *fd, *tmpfd;
|
|
|
|
/* update highest version */
|
|
if (new->version > parent->chvc->highest_version) {
|
|
parent->chvc->highest_version = new->version;
|
|
}
|
|
|
|
TAILQ_FOREACH_SAFE(fd, &parent->dents, fds, tmpfd) {
|
|
if (fd->nhash > new->nhash) {
|
|
/* insert new before fd */
|
|
TAILQ_INSERT_BEFORE(fd, new, fds);
|
|
return;
|
|
} else if (fd->nhash == new->nhash &&
|
|
!strcmp(fd->name, new->name)) {
|
|
if (new->version > fd->version) {
|
|
/* replace fd with new */
|
|
TAILQ_INSERT_BEFORE(fd, new, fds);
|
|
TAILQ_REMOVE(&parent->dents, fd, fds);
|
|
if (fd->nref) {
|
|
mutex_enter(&chmp->chm_lock_vnocache);
|
|
chfs_remove_and_obsolete(chmp, parent->chvc, fd->nref,
|
|
&parent->chvc->dirents);
|
|
mutex_exit(&chmp->chm_lock_vnocache);
|
|
}
|
|
chfs_free_dirent(fd);
|
|
} else {
|
|
/* new is older (normally it's not an option) */
|
|
chfs_mark_node_obsolete(chmp, new->nref);
|
|
chfs_free_dirent(new);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
/* if we couldnt fit it elsewhere, lets add to the end */
|
|
/* FIXME insert tail or insert head? */
|
|
TAILQ_INSERT_HEAD(&parent->dents, new, fds);
|
|
}
|
|
|
|
|
|
/* chfs_add_vnode_ref_to_vc - adds a vnode info to the vnode cache */
|
|
void
|
|
chfs_add_vnode_ref_to_vc(struct chfs_mount *chmp,
|
|
struct chfs_vnode_cache *vc, struct chfs_node_ref *new)
|
|
{
|
|
KASSERT(mutex_owned(&chmp->chm_lock_vnocache));
|
|
struct chfs_node_ref *nref;
|
|
|
|
/* store only the last one, drop the others */
|
|
while (vc->v != (struct chfs_node_ref *)vc) {
|
|
nref = vc->v;
|
|
chfs_remove_and_obsolete(chmp, vc, nref, &vc->v);
|
|
}
|
|
|
|
new->nref_next = (struct chfs_node_ref *)vc;
|
|
vc->v = new;
|
|
}
|
|
|
|
/* chfs_nref_next - step to the next in-memory nref */
|
|
struct chfs_node_ref *
|
|
chfs_nref_next(struct chfs_node_ref *nref)
|
|
{
|
|
nref++;
|
|
if (nref->nref_lnr == REF_LINK_TO_NEXT) {
|
|
/* end of chain */
|
|
if (!nref->nref_next)
|
|
return NULL;
|
|
|
|
/* link to the next block */
|
|
nref = nref->nref_next;
|
|
}
|
|
/* end of chain */
|
|
if (nref->nref_lnr == REF_EMPTY_NODE)
|
|
return NULL;
|
|
|
|
return nref;
|
|
}
|
|
|
|
/* chfs_nref_len - calculates the length of an nref */
|
|
int
|
|
chfs_nref_len(struct chfs_mount *chmp,
|
|
struct chfs_eraseblock *cheb, struct chfs_node_ref *nref)
|
|
{
|
|
struct chfs_node_ref *next;
|
|
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
|
|
if (!cheb)
|
|
cheb = &chmp->chm_blocks[nref->nref_lnr];
|
|
|
|
next = chfs_nref_next(nref);
|
|
|
|
if (!next) {
|
|
return chmp->chm_ebh->eb_size - cheb->free_size -
|
|
CHFS_GET_OFS(nref->nref_offset);
|
|
}
|
|
return CHFS_GET_OFS(next->nref_offset) -
|
|
CHFS_GET_OFS(nref->nref_offset);
|
|
}
|
|
|
|
/* chfs_mark_node_obsolete - marks a node as obsolete */
|
|
void
|
|
chfs_mark_node_obsolete(struct chfs_mount *chmp,
|
|
struct chfs_node_ref *nref)
|
|
{
|
|
int len;
|
|
struct chfs_eraseblock *cheb;
|
|
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
|
|
KASSERT(!CHFS_REF_OBSOLETE(nref));
|
|
|
|
KASSERT(nref->nref_lnr <= chmp->chm_ebh->peb_nr);
|
|
cheb = &chmp->chm_blocks[nref->nref_lnr];
|
|
|
|
#ifdef DIAGNOSTIC
|
|
if (cheb->used_size + cheb->free_size + cheb->dirty_size +
|
|
cheb->unchecked_size + cheb->wasted_size != chmp->chm_ebh->eb_size) {
|
|
dbg("eraseblock leak detected!\nused: %u\nfree: %u\n"
|
|
"dirty: %u\nunchecked: %u\nwasted: %u\ntotal: %u\nshould be: %zu\n",
|
|
cheb->used_size, cheb->free_size, cheb->dirty_size,
|
|
cheb->unchecked_size, cheb->wasted_size, cheb->used_size + cheb->free_size +
|
|
cheb->dirty_size + cheb->unchecked_size + cheb->wasted_size,
|
|
chmp->chm_ebh->eb_size);
|
|
}
|
|
#endif
|
|
|
|
len = chfs_nref_len(chmp, cheb, nref);
|
|
|
|
mutex_enter(&chmp->chm_lock_sizes);
|
|
|
|
if (CHFS_REF_FLAGS(nref) == CHFS_UNCHECKED_NODE_MASK) {
|
|
chfs_change_size_unchecked(chmp, cheb, -len);
|
|
} else {
|
|
chfs_change_size_used(chmp, cheb, -len);
|
|
|
|
KASSERT(cheb->used_size <= chmp->chm_ebh->eb_size);
|
|
}
|
|
chfs_change_size_dirty(chmp, cheb, len);
|
|
|
|
#ifdef DIAGNOSTIC
|
|
if (cheb->used_size + cheb->free_size + cheb->dirty_size +
|
|
cheb->unchecked_size + cheb->wasted_size != chmp->chm_ebh->eb_size) {
|
|
panic("eraseblock leak detected!\nused: %u\nfree: %u\n"
|
|
"dirty: %u\nunchecked: %u\nwasted: %u\ntotal: %u\nshould be: %zu\n",
|
|
cheb->used_size, cheb->free_size, cheb->dirty_size,
|
|
cheb->unchecked_size, cheb->wasted_size, cheb->used_size + cheb->free_size +
|
|
cheb->dirty_size + cheb->unchecked_size + cheb->wasted_size,
|
|
chmp->chm_ebh->eb_size);
|
|
}
|
|
#endif
|
|
nref->nref_offset = CHFS_GET_OFS(nref->nref_offset) |
|
|
CHFS_OBSOLETE_NODE_MASK;
|
|
|
|
if (chmp->chm_flags & CHFS_MP_FLAG_SCANNING) {
|
|
/*Scan is in progress, do nothing now*/
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
return;
|
|
}
|
|
|
|
if (cheb == chmp->chm_nextblock) {
|
|
dbg("Not moving nextblock to dirty/erase_pending list\n");
|
|
} else if (!cheb->used_size && !cheb->unchecked_size) {
|
|
if (cheb == chmp->chm_gcblock) {
|
|
dbg("gcblock is completely dirtied\n");
|
|
chmp->chm_gcblock = NULL;
|
|
} else {
|
|
/* remove from a tailq, but we don't know which tailq contains this cheb
|
|
* so we remove it from the dirty list now */
|
|
//TAILQ_REMOVE(&chmp->chm_dirty_queue, cheb, queue);
|
|
int removed = 0;
|
|
struct chfs_eraseblock *eb, *tmpeb;
|
|
//XXX ugly code
|
|
TAILQ_FOREACH_SAFE(eb, &chmp->chm_free_queue, queue, tmpeb) {
|
|
if (eb == cheb) {
|
|
TAILQ_REMOVE(&chmp->chm_free_queue, cheb, queue);
|
|
removed = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (removed == 0) {
|
|
TAILQ_FOREACH_SAFE(eb, &chmp->chm_dirty_queue, queue, tmpeb) {
|
|
if (eb == cheb) {
|
|
TAILQ_REMOVE(&chmp->chm_dirty_queue, cheb, queue);
|
|
removed = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (removed == 0) {
|
|
TAILQ_FOREACH_SAFE(eb, &chmp->chm_very_dirty_queue, queue, tmpeb) {
|
|
if (eb == cheb) {
|
|
TAILQ_REMOVE(&chmp->chm_very_dirty_queue, cheb, queue);
|
|
removed = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (removed == 0) {
|
|
TAILQ_FOREACH_SAFE(eb, &chmp->chm_clean_queue, queue, tmpeb) {
|
|
if (eb == cheb) {
|
|
TAILQ_REMOVE(&chmp->chm_clean_queue, cheb, queue);
|
|
removed = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (chmp->chm_wbuf_len) {
|
|
dbg("Adding block to erasable pending wbuf queue\n");
|
|
TAILQ_INSERT_TAIL(&chmp->chm_erasable_pending_wbuf_queue,
|
|
cheb, queue);
|
|
} else {
|
|
TAILQ_INSERT_TAIL(&chmp->chm_erase_pending_queue,
|
|
cheb, queue);
|
|
chmp->chm_nr_erasable_blocks++;
|
|
}
|
|
chfs_remap_leb(chmp);
|
|
} else if (cheb == chmp->chm_gcblock) {
|
|
dbg("Not moving gcblock to dirty list\n");
|
|
} else if (cheb->dirty_size > MAX_DIRTY_TO_CLEAN &&
|
|
cheb->dirty_size - len <= MAX_DIRTY_TO_CLEAN) {
|
|
dbg("Freshly dirtied, remove it from clean queue and "
|
|
"add it to dirty\n");
|
|
TAILQ_REMOVE(&chmp->chm_clean_queue, cheb, queue);
|
|
TAILQ_INSERT_TAIL(&chmp->chm_dirty_queue, cheb, queue);
|
|
} else if (VERY_DIRTY(chmp, cheb->dirty_size) &&
|
|
!VERY_DIRTY(chmp, cheb->dirty_size - len)) {
|
|
dbg("Becomes now very dirty, remove it from dirty "
|
|
"queue and add it to very dirty\n");
|
|
TAILQ_REMOVE(&chmp->chm_dirty_queue, cheb, queue);
|
|
TAILQ_INSERT_TAIL(&chmp->chm_very_dirty_queue, cheb, queue);
|
|
} else {
|
|
dbg("Leave cheb where it is\n");
|
|
}
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* chfs_close_eraseblock - close an eraseblock
|
|
*
|
|
* This function close the physical chain of the nodes on the eraseblock,
|
|
* convert its free size to dirty and add it to clean, dirty or very dirty list.
|
|
*/
|
|
int
|
|
chfs_close_eraseblock(struct chfs_mount *chmp,
|
|
struct chfs_eraseblock *cheb)
|
|
{
|
|
uint32_t offset;
|
|
struct chfs_node_ref *nref;
|
|
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
|
|
offset = chmp->chm_ebh->eb_size - cheb->free_size;
|
|
|
|
// Close the chain
|
|
nref = chfs_alloc_node_ref(cheb);
|
|
if (!nref)
|
|
return ENOMEM;
|
|
|
|
nref->nref_next = NULL;
|
|
nref->nref_offset = offset;
|
|
|
|
// Mark space as dirty
|
|
chfs_update_eb_dirty(chmp, cheb, cheb->free_size);
|
|
|
|
if (cheb->dirty_size < MAX_DIRTY_TO_CLEAN) {
|
|
TAILQ_INSERT_TAIL(&chmp->chm_clean_queue, cheb, queue);
|
|
} else if (VERY_DIRTY(chmp, cheb->dirty_size)) {
|
|
TAILQ_INSERT_TAIL(&chmp->chm_very_dirty_queue, cheb, queue);
|
|
} else {
|
|
TAILQ_INSERT_TAIL(&chmp->chm_dirty_queue, cheb, queue);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* chfs_reserve_space_normal -
|
|
* checks available space and calls chfs_reserve_space
|
|
* used during writing
|
|
*/
|
|
int
|
|
chfs_reserve_space_normal(struct chfs_mount *chmp, uint32_t size, int prio)
|
|
{
|
|
int ret;
|
|
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
|
|
mutex_enter(&chmp->chm_lock_sizes);
|
|
while (chmp->chm_nr_free_blocks + chmp->chm_nr_erasable_blocks < chmp->chm_resv_blocks_write) {
|
|
dbg("free: %d, erasable: %d, resv: %d\n", chmp->chm_nr_free_blocks, chmp->chm_nr_erasable_blocks, chmp->chm_resv_blocks_write);
|
|
uint32_t avail, dirty;
|
|
if (prio == ALLOC_DELETION && chmp->chm_nr_free_blocks + chmp->chm_nr_erasable_blocks >= chmp->chm_resv_blocks_deletion)
|
|
break;
|
|
|
|
dirty = chmp->chm_dirty_size - chmp->chm_nr_erasable_blocks * chmp->chm_ebh->eb_size + chmp->chm_unchecked_size;
|
|
if (dirty < chmp->chm_nospc_dirty) {
|
|
dbg("dirty: %u < nospc_dirty: %u\n", dirty, chmp->chm_nospc_dirty);
|
|
ret = ENOSPC;
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
goto out;
|
|
}
|
|
|
|
avail = chmp->chm_free_size - (chmp->chm_resv_blocks_write * chmp->chm_ebh->eb_size);
|
|
if (size > avail) {
|
|
dbg("size: %u > avail: %u\n", size, avail);
|
|
ret = ENOSPC;
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
goto out;
|
|
}
|
|
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
ret = chfs_gcollect_pass(chmp);
|
|
mutex_enter(&chmp->chm_lock_sizes);
|
|
|
|
if (chmp->chm_nr_erasable_blocks ||
|
|
!TAILQ_EMPTY(&chmp->chm_erasable_pending_wbuf_queue) ||
|
|
ret == EAGAIN) {
|
|
ret = chfs_remap_leb(chmp);
|
|
}
|
|
|
|
if (ret) {
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
ret = chfs_reserve_space(chmp, size);
|
|
out:
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* chfs_reserve_space_gc - tries to reserve space for GC */
|
|
int
|
|
chfs_reserve_space_gc(struct chfs_mount *chmp, uint32_t size)
|
|
{
|
|
int ret;
|
|
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
|
|
mutex_enter(&chmp->chm_lock_sizes);
|
|
chfs_remap_leb(chmp);
|
|
|
|
if (size > chmp->chm_free_size) {
|
|
dbg("size: %u\n", size);
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
return ENOSPC;
|
|
}
|
|
|
|
mutex_exit(&chmp->chm_lock_sizes);
|
|
ret = chfs_reserve_space(chmp, size);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* chfs_reserve_space - finds a block which free size is >= requested size
|
|
* Returns zero in case of success, error code in case of fail.
|
|
*/
|
|
int
|
|
chfs_reserve_space(struct chfs_mount *chmp, uint32_t size)
|
|
{
|
|
//TODO define minimum reserved blocks, which is needed for writing
|
|
//TODO check we have enough free blocks to write
|
|
//TODO if no: need erase and GC
|
|
|
|
int err;
|
|
struct chfs_eraseblock *cheb;
|
|
|
|
KASSERT(mutex_owned(&chmp->chm_lock_mountfields));
|
|
KASSERT(!mutex_owned(&chmp->chm_lock_sizes));
|
|
|
|
cheb = chmp->chm_nextblock;
|
|
if (cheb && size > cheb->free_size) {
|
|
dbg("size: %u > free_size: %u\n", size, cheb->free_size);
|
|
/*
|
|
* There isn't enough space on this eraseblock, we mark this as
|
|
* dirty and close the physical chain of the node refs.
|
|
*/
|
|
//Write out pending data if any
|
|
if (chmp->chm_wbuf_len) {
|
|
chfs_flush_pending_wbuf(chmp);
|
|
//FIXME need goto restart here?
|
|
}
|
|
|
|
while (chmp->chm_wbuf_ofs < chmp->chm_ebh->eb_size) {
|
|
dbg("wbuf ofs: %zu - eb_size: %zu\n",
|
|
chmp->chm_wbuf_ofs, chmp->chm_ebh->eb_size);
|
|
chfs_flush_pending_wbuf(chmp);
|
|
}
|
|
|
|
if (!(chmp->chm_wbuf_ofs % chmp->chm_ebh->eb_size) && !chmp->chm_wbuf_len)
|
|
chmp->chm_wbuf_ofs = 0xffffffff;
|
|
|
|
err = chfs_close_eraseblock(chmp, cheb);
|
|
if (err)
|
|
return err;
|
|
|
|
cheb = NULL;
|
|
}
|
|
if (!cheb) {
|
|
//get a block for nextblock
|
|
if (TAILQ_EMPTY(&chmp->chm_free_queue)) {
|
|
// If this succeeds there will be a block on free_queue
|
|
dbg("cheb remap (free: %d)\n", chmp->chm_nr_free_blocks);
|
|
err = chfs_remap_leb(chmp);
|
|
if (err)
|
|
return err;
|
|
}
|
|
cheb = TAILQ_FIRST(&chmp->chm_free_queue);
|
|
TAILQ_REMOVE(&chmp->chm_free_queue, cheb, queue);
|
|
chmp->chm_nextblock = cheb;
|
|
chmp->chm_nr_free_blocks--;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|