/*----------------------------------------------------------------------------*/
/*ncache.h*/
/*----------------------------------------------------------------------------*/
/*The implementation of the cache of nodes*/
/*----------------------------------------------------------------------------*/
/*Based on the code of unionfs translator.*/
/*----------------------------------------------------------------------------*/
/*Copyright (C) 2001, 2002, 2005 Free Software Foundation, Inc.
Written by Sergiu Ivanov <unlimitedscolobb@gmail.com>.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or * (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.*/
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
#define _GNU_SOURCE 1
/*----------------------------------------------------------------------------*/
#include "ncache.h"
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/*--------Global Variables----------------------------------------------------*/
/*The global cache chain*/
ncache_t ncache;
/*----------------------------------------------------------------------------*/
/*Cache size (may be overwritten by the user)*/
int ncache_size = NCACHE_SIZE;
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/*--------Functions-----------------------------------------------------------*/
/*Initializes the node cache*/
void
ncache_init
(
int size_max
)
{
/*Reset the LRU and MRU ends of the list*/
ncache.mru = ncache.lru = NULL;
/*Set the maximal size according to the parameter*/
ncache.size_max = size_max;
/*The cache is empty so far; remark that*/
ncache.size_current = 0;
/*Init the lock*/
mutex_init(&ncache.lock);
}/*ncache_init*/
/*----------------------------------------------------------------------------*/
/*Looks up the lnode and stores the result in `node`; creates a new entry
in the cache if the lookup fails*/
error_t
ncache_node_lookup
(
lnode_t * lnode, /*search for this*/
node_t ** node /*put the result here*/
)
{
error_t err = 0;
/*Obtain the pointer to the node corresponding to `lnode`*/
node_t * n = lnode->node;
/*If a node has already been created for the given lnode*/
if(n != NULL)
{
/*count a new reference to 'n'*/
netfs_nref(n);
}
else
{
/*create a new node for the given lnode and store the result in `n`*/
err = node_create(lnode, &n);
}
/*If no errors have occurred during the previous operations*/
if(!err)
{
/*lock the mutex in the looked up node*/
mutex_lock(&n->lock);
/*store the lookup result in `node`*/
*node = n;
}
/*Return the result of operations*/
return err;
}/*ncache_node_lookup*/
/*----------------------------------------------------------------------------*/
/*Removes the given node from the cache*/
static
void
ncache_node_remove
(
node_t * node
)
{
/*Obtain the pointer to the netnode (this contains the information
specific of us)*/
struct netnode * nn = node->nn;
/*If there exists a successor of this node in the cache chain*/
if(nn->ncache_next)
/*remove the reference in the successor*/
nn->ncache_next->nn->ncache_prev = nn->ncache_prev;
/*If there exists a predecessor of this node in the cache chain*/
if(nn->ncache_prev)
/*remove the reference in the predecessor*/
nn->ncache_prev->nn->ncache_next = nn->ncache_next;
/*If the node was located at the MRU end of the list*/
if(ncache.mru == node)
/*shift the MRU end to the next node*/
ncache.mru = nn->ncache_next;
/*If the node was located at the LRU end of the list*/
if(ncache.lru == node)
/*shift the LRU end to the previous node*/
ncache.lru = nn->ncache_prev;
/*Invalidate the references inside the node*/
nn->ncache_next = nn->ncache_prev = NULL;
/*Count the removal of a node*/
--ncache.size_current;
}/*ncache_node_remove*/
/*----------------------------------------------------------------------------*/
/*Resets the node cache*/
void
ncache_reset(void)
{
/*The node being currently deleted*/
node_t * node;
/*Acquire a lock on the cache*/
mutex_lock(&ncache.lock);
/*Remove the whole cache chain*/
for(node = ncache.mru; node != NULL; ncache_node_remove(node), node = ncache.mru);
/*Release the lock*/
mutex_unlock(&ncache.lock);
}/*ncache_reset*/
/*----------------------------------------------------------------------------*/
/*Adds the given node to the cache*/
void
ncache_node_add
(
node_t * node /*the node to add*/
)
{
/*Acquire a lock on the cache*/
mutex_lock(&ncache.lock);
/*If there already are some nodes in the cache and it is enabled*/
if((ncache.size_max > 0) || (ncache.size_current > 0))
{
/*If the node to be added is not at the MRU end already*/
if(ncache.mru != node)
{
/*If the node is correctly integrated in the cache*/
if((node->nn->ncache_next != NULL) && (node->nn->ncache_prev != NULL))
/*remove the old entry*/
ncache_node_remove(node);
else
/*add a new reference to the node*/
netfs_nref(node);
/*put the node at the MRU end of the cache chain*/
node->nn->ncache_next = ncache.mru;
node->nn->ncache_prev = NULL;
/*setup the pointer in the old MRU end, if it exists*/
if(ncache.mru != NULL)
ncache.mru->nn->ncache_prev = node;
/*setup the LRU end of the cache chain, if it did not exist previously*/
if(ncache.lru == NULL)
ncache.lru = node;
/*shift the MRU end to the new node*/
ncache.mru = node;
/*count the addition*/
++ncache.size_current;
}
}
/*While the size of the cache is exceeding the maximal size*/
node_t * old_lru;
for
(
old_lru = ncache.lru;
ncache.size_current > ncache.size_max;
old_lru = ncache.lru
)
{
/*remove the current LRU end of the list from the cache*/
ncache_node_remove(old_lru);
/*release the reference to the node owned by this thread*/
netfs_nrele(old_lru);
}
/*Release the lock on the cache*/
mutex_unlock(&ncache.lock);
}/*ncache_node_add*/
/*----------------------------------------------------------------------------*/
