/* Copyright (C) 2005      David Decotigny
    Copyright (C) 2000-2005 The KOS Team (Thomas Petazzoni, David
                            Decotigny, Julien Munier)
 
    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. 
 */
 
 #include <sos/assert.h>
 #include <sos/list.h>
 #include <sos/kmem_slab.h>
 #include <sos/kmalloc.h>
 
 #include "fs_nscache.h"
 
 
 /**
  * A so-called "dentry" / "nsnode" structure. Used to make the
  * "in-memory" representation of the file system files/dir/devices
  * that have been used up to now
  */
 struct sos_fs_nscache_node
 {
   /** The reference to the associated sos_fs_node */
   struct sos_fs_node     *fs_node;
 
   struct sos_fs_pathname name;
 
   /** Number of references to that node, reference from parent (if
       any) is EXCLUDED */
   sos_count_t ref_cnt;
 
   /*
    * Ued to chain the mounted filesystem
    */
 
   /** If this node is a mountpoint (a file system is mounted on it):
       reference to the filesystem mounted on it */
   struct sos_fs_nscache_node *mounted_root;
   /** If this node is the root of a mounted filesystem: reference to
       the mountpoint where it is mounted on */
   struct sos_fs_nscache_node *mountpoint;
 
   /** ".." */
   struct sos_fs_nscache_node *parent;
 
   /** List of the already known children */
   struct sos_fs_nscache_node *children;
   
   /** Other children for the same parent */
   struct sos_fs_nscache_node *siblings_prev, *siblings_next;
 };
 
 
 /** The cache of nscache_node objects */
 static struct sos_kslab_cache * cache_of_nscache_nodes;
 
 
 sos_ret_t sos_fs_nscache_subsystem_setup()
 {
   cache_of_nscache_nodes
     = sos_kmem_cache_create("fs_nscache",
                             sizeof(struct sos_fs_nscache_node),
                             3, 0,
                             SOS_KSLAB_CREATE_MAP | SOS_KSLAB_CREATE_ZERO);
   if (! cache_of_nscache_nodes)
     return -SOS_ENOMEM;
 
   return SOS_OK;
 };
 
 
 sos_bool_t
 sos_fs_pathname_eat_slashes(const struct sos_fs_pathname * path,
                             struct sos_fs_pathname * result)
 {
   sos_bool_t retval = FALSE;
 
   result->contents = path->contents;
   result->length   = path->length;
   while (result->length > 0)
     {
       if (*result->contents != '/')
         break;
 
       result->contents ++;
       result->length --;
       retval = TRUE;
     }
 
   if(result->length <= 0)
     result->contents = NULL;
 
   return retval;
 }
 
 
 static sos_bool_t
 sos_fs_pathname_eat_non_slashes(const struct sos_fs_pathname * path,
                                 struct sos_fs_pathname * result)
 {
   sos_bool_t retval = FALSE;
 
   result->contents = path->contents;
   result->length   = path->length;
   while (result->length > 0)
     {
       if (*result->contents == '/')
         break;
 
       result->contents ++;
       result->length --;
       retval = TRUE;
     }
 
   if(result->length <= 0)
     result->contents = NULL;
 
   return retval;
 }
 
 
 sos_bool_t
 sos_fs_pathname_split_path(const struct sos_fs_pathname * path,
                            struct sos_fs_pathname * result_first_component,
                            struct sos_fs_pathname * result_remaining_path)
 {
   result_first_component->contents = path->contents;
   result_first_component->length   = path->length;
 
   /* Skip any leading slash */
   sos_fs_pathname_eat_slashes(result_first_component,
                               result_first_component);
 
   /* Extract the first component */
   sos_fs_pathname_eat_non_slashes(result_first_component,
                                   result_remaining_path);
   SOS_ASSERT_FATAL(result_remaining_path->length >= 0);
   result_first_component->length -= result_remaining_path->length;
 
   /* Return true if there is something left (at least one slash) */
   return (result_remaining_path->length > 0);
 }
 
 
 sos_bool_t fs_pathname_iseq(const struct sos_fs_pathname * p1,
                             const struct sos_fs_pathname * p2)
 {
   if (!p1->contents)
     SOS_ASSERT_FATAL(p1->length == 0);
   if (!p2->contents)
     SOS_ASSERT_FATAL(p2->length == 0);
 
   if (p1->length != p2->length)
     return FALSE;
 
   if (p1->length == 0)
     return TRUE;
 
   return (0 == memcmp(p1->contents, p2->contents, p1->length));
 }
 
 
 #define fs_pathname_isstr(str,path) \
   ({ struct sos_fs_pathname _s; _s.contents = str; _s.length = sizeof(str)-1; \
      fs_pathname_iseq(&_s, (path)); })
 
 
 struct sos_fs_node *
 sos_fs_nscache_get_fs_node(const struct sos_fs_nscache_node * nsnode)
 {
   return nsnode->fs_node;
 }
 
 
 sos_ret_t
 sos_fs_nscache_get_parent(const struct sos_fs_nscache_node * nsnode,
                           struct sos_fs_nscache_node ** result_parent)
 {
   *result_parent = nsnode->parent;
   if (*result_parent)
     return SOS_OK;
   return -SOS_ENOENT;
 }
 
 
 sos_ret_t
 sos_fs_nscache_get_name(const struct sos_fs_nscache_node * nsnode,
                         struct sos_fs_pathname * result_pathname)
 {
   result_pathname->contents = nsnode->name.contents;
   result_pathname->length   = nsnode->name.length;
   return SOS_OK;
 }
 
 
 sos_ret_t
 sos_fs_nscache_get_ref_cnt(const struct sos_fs_nscache_node * nsnode)
 {
   return nsnode->ref_cnt;
 }
 
 
 sos_ret_t
 sos_fs_nscache_lookup(struct sos_fs_nscache_node * cur_nsnode,
                       const struct sos_fs_pathname * node_name,
                       const struct sos_fs_nscache_node * root_nsnode,
                       struct sos_fs_nscache_node ** result_nsnode)
 {
   if (fs_pathname_isstr(".", node_name))
     {
       *result_nsnode = cur_nsnode;
     }
   else if (fs_pathname_isstr("..", node_name))
     {
       /* Effectively go up only if we did not reach a root node */
       if (cur_nsnode == root_nsnode) /* did reach chroot */
         {
           /* Simply stay here */
           *result_nsnode = cur_nsnode;
         }
       else
         {
           /* If current node is a mounted FS, rewind the mountpoint
              chain */
           for ( ; cur_nsnode->mountpoint ; cur_nsnode = cur_nsnode->mountpoint)
             /* nop */ ;
 
           /* Now go up to parent */
           SOS_ASSERT_FATAL(NULL != cur_nsnode->parent);
           *result_nsnode = cur_nsnode->parent;
         }
 
       /* Update the nscache_node result */
       sos_fs_nscache_ref_node(*result_nsnode);
       return SOS_OK;
     }
   else
     {
       /* Normal lookup: we iterate over the list of children nscache
          nodes */
       int nb_children;
       struct sos_fs_nscache_node * child;
 
       /* Lookup the child node with the correct name, if any */
       list_foreach_named(cur_nsnode->children,
                          child, nb_children,
                          siblings_prev, siblings_next)
         {
           struct sos_fs_node * fs_node = cur_nsnode->fs_node;
           
           if (fs_node->fs->nsnode_same_name)
             {
               if (fs_node->fs->
                     nsnode_same_name(child->name.contents,
                                      child->name.length,
                                      node_name->contents,
                                      node_name->length))
                 break;
             }
           else
             if (fs_pathname_iseq(& child->name,
                                  node_name))
               break;
         }
 
       /* Did not find it ! */
       if (! list_foreach_early_break(cur_nsnode->children,
                                      child, nb_children))
         return -SOS_ENOENT;
 
       /* Yes, found it ! */
       *result_nsnode = child;
     }
 
   /* Found it. Now, Follow the mountpoint chain, if any */
   for ( ; (*result_nsnode)->mounted_root ;
         *result_nsnode = (*result_nsnode)->mounted_root)
     /* nop */ ;
 
   /* Update the nscache_node result */
   sos_fs_nscache_ref_node(*result_nsnode);
 
   return SOS_OK;
 }
 
 
 sos_ret_t sos_fs_nscache_ref_node(struct sos_fs_nscache_node * nsnode)
 {
   SOS_ASSERT_FATAL(nsnode->ref_cnt > 0);
   nsnode->ref_cnt ++;
   return SOS_OK;
 }
 
 
 /* Eventually collapses a whole list of nsnodes (non recursive) */
 sos_ret_t _sos_fs_nscache_unref_node(struct sos_fs_nscache_node ** nsnode)
 {
   struct sos_fs_nscache_node * to_delete = NULL, *node;
 
   node = *nsnode;
   *nsnode = NULL;
 
   while (node)
     {
       /* Unreference this node */
       SOS_ASSERT_FATAL(node->ref_cnt > 0);
       node->ref_cnt --;
 
       /* Is it a good candidate for deletion ? */
       if (node->ref_cnt > 0)
         break; /* No */
 
       if (node->parent)
         {
           struct sos_fs_nscache_node * parent = node->parent;
 
           SOS_ASSERT_FATAL(node->parent->ref_cnt >= 1);
 
           list_delete_named(parent->children, node,
                             siblings_prev, siblings_next);
           /* The parent lost one child: next iteration will decrement
              ths parent's ref cnt */
         }
 
       /* Add to the list of elements to suppress */
       list_add_tail_named(to_delete, node, siblings_prev, siblings_next);
 
       /* Now look if parent (if any) can be destroyed */
       node = node->parent;
     }
 
   /* Now destroy all the elements gathered */
   while (! list_is_empty_named(to_delete, siblings_prev, siblings_next))
     {
       node = list_pop_head_named(to_delete, siblings_prev, siblings_next);
       sos_fs_unref_fsnode(node->fs_node);
       sos_kfree((sos_vaddr_t)node);
     }
 
   return SOS_OK;
 }
 
 
 sos_ret_t
 sos_fs_nscache_add_new_child_node(struct sos_fs_nscache_node * parent,
                                   const struct sos_fs_pathname * node_name,
                                   struct sos_fs_node * fsnode,
                                   struct sos_fs_nscache_node ** result_nsnode)
 {
   struct sos_fs_nscache_node * nsnode;
 
   /* Allocate a new nscache node from slab */
   nsnode = (struct sos_fs_nscache_node*)
     sos_kmem_cache_alloc(cache_of_nscache_nodes,
                          SOS_KSLAB_ALLOC_ATOMIC);
   if (! nsnode)
     return -SOS_ENOMEM;
 
   /* Allocate a new memory chunk to hold the node's name */
   if (node_name && (node_name->length > 0))
     {
       char * contents = (char*) sos_kmalloc(node_name->length,
                                             SOS_KMALLOC_ATOMIC);
       if (! contents)
         {
           sos_kfree((sos_vaddr_t)nsnode);
           return -SOS_ENOMEM;
         }
 
       memcpy(contents, node_name->contents, node_name->length);
       nsnode->name.contents = contents;
       nsnode->name.length   = node_name->length;
     }
 
   /* Now initialize the new node's fields */
   nsnode->ref_cnt = 1;
   sos_fs_ref_fsnode(fsnode);
   nsnode->fs_node = fsnode;
 
   /* Register this node as a child of its parent, if any */
   nsnode->parent  = parent;
   if (parent)
     {
       sos_fs_nscache_ref_node(parent);
       list_add_head_named(parent->children, nsnode,
                           siblings_prev, siblings_next);
     }
 
   *result_nsnode = nsnode;
   return SOS_OK;
 }
 
 
 sos_ret_t
 sos_fs_nscache_add_existing_child_node(struct sos_fs_nscache_node * parent,
                                        const struct sos_fs_pathname * node_name,
                                        struct sos_fs_nscache_node * nsnode)
 {
   SOS_ASSERT_FATAL(nsnode->parent == NULL);
 
   /* If the node already had a name, suppress it */
   if (NULL != nsnode->name.contents)
     {
       sos_kfree((sos_vaddr_t)nsnode->name.contents);
     }
   memset(& nsnode->name, 0x0, sizeof(struct sos_fs_pathname));
 
   /* Allocate a new memory chunk to hold the node's name */
   if (node_name && (node_name->length > 0))
     {
       char * contents = (char*) sos_kmalloc(node_name->length,
                                             SOS_KMALLOC_ATOMIC);
       if (! contents)
         {
           sos_kfree((sos_vaddr_t)nsnode);
           return -SOS_ENOMEM;
         }
 
       memcpy(contents, node_name->contents, node_name->length);
       nsnode->name.contents = contents;
       nsnode->name.length   = node_name->length;
     }
 
 
   /* Register this node as a child of its parent, if any */
   nsnode->parent  = parent;
   if (parent)
     {
       sos_fs_nscache_ref_node(parent);
       list_add_head_named(parent->children, nsnode,
                           siblings_prev, siblings_next);
     }
   return SOS_OK;
 }
 
 
 sos_ret_t
 sos_fs_nscache_disconnect_node(struct sos_fs_nscache_node * nsnode)
 {
   if (! nsnode->parent)
     return SOS_OK;
 
   list_delete_named(nsnode->parent->children, nsnode,
                     siblings_prev, siblings_next);
   sos_fs_nscache_unref_node(nsnode->parent);
   nsnode->parent = NULL;
 
   return SOS_OK;
 }
 
 
 sos_ret_t
 sos_fs_nscache_register_opened_file(struct sos_fs_nscache_node * nsnode,
                                     struct sos_fs_opened_file * of)
 {
   of->direntry = nsnode;
   sos_fs_nscache_ref_node(nsnode);
   return SOS_OK;
 }
 
 
 sos_ret_t
 sos_fs_nscache_mount(struct sos_fs_nscache_node * mountpoint,
                      struct sos_fs_nscache_node * mounted_root)
 {
   SOS_ASSERT_FATAL(NULL == mountpoint->mounted_root);
   SOS_ASSERT_FATAL(NULL == mounted_root->mountpoint);
   mountpoint->mounted_root = mounted_root;
   mounted_root->mountpoint = mountpoint;
   sos_fs_nscache_ref_node(mountpoint);
   sos_fs_nscache_ref_node(mounted_root);
   
   return SOS_OK;
 }
 
 
 sos_ret_t
 sos_fs_nscache_umount(struct sos_fs_nscache_node * mounted_root)
 {
   struct sos_fs_manager_instance *fs;
 
   SOS_ASSERT_FATAL(NULL != mounted_root->mountpoint);
   SOS_ASSERT_FATAL(mounted_root->mountpoint->mounted_root == mounted_root);
 
   /* No FS should be mounted on the mounted root to umount */
   SOS_ASSERT_FATAL(NULL == mounted_root->mounted_root);
 
   /* The mounted root should have its own reference, plus a reference
      from the mountpoint and from the fs instance */
   SOS_ASSERT_FATAL(mounted_root->ref_cnt >= 3);
   if (mounted_root->ref_cnt != 3)
     return -SOS_EBUSY;
 
   fs = mounted_root->fs_node->fs;
   SOS_ASSERT_FATAL(NULL != fs);
   SOS_ASSERT_FATAL(fs->root == mounted_root);
 
   /* Undo the mountpoint <-> mounted_root mutual reference */
   mounted_root->mountpoint->mounted_root = NULL;
   sos_fs_nscache_unref_node(mounted_root->mountpoint);
   mounted_root->mountpoint = NULL;
   sos_fs_nscache_unref_node(mounted_root);
 
   /* Undo the fs->root -> mounted_root reference */
   sos_fs_nscache_unref_node(fs->root);
 
   return SOS_OK;
 }
 
 sos_bool_t
 sos_fs_nscache_is_mountnode(const struct sos_fs_nscache_node * nsnode)
 {
   return ( (NULL != nsnode->mounted_root) || (NULL != nsnode->mountpoint) );
 }