/* Copyright (C) 2005 David Decotigny
 
    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/kmalloc.h>
 #include <sos/physmem.h>
 #include <hwcore/paging.h>
 #include <sos/kmem_slab.h>
 #include <sos/list.h>
 #include <hwcore/paging.h>
 #include <sos/uaccess.h>
 #include <sos/chardev.h>
 #include <drivers/devices.h>
 
 #include "zero.h"
 
 
 /**
  * A mapped page for a shared mapping of /dev/zero
  */
 struct zero_mapped_page
 {
   sos_uoffset_t page_id;
   sos_paddr_t   ppage_paddr;
 
   struct zero_mapped_page *prev, *next;
 };
 /** The Slab cache of shared mapped pages */
 struct sos_kslab_cache * cache_of_zero_mapped_pages;
 
 
 /**
  * A mapped /dev/zero resource
  */
 struct zero_mapped_resource
 {
   int ref_cnt;
 
   /**
    * For shared mappings: the list of shared pages mapped inside one
    * or multiple VRs
    */
   struct zero_mapped_page *list_mapped_pages;
 
   struct sos_umem_vmm_mapped_resource mr;
 };
 
 
 /** Forward declaration: the FS operation for the /dev/zero character
     device */
 static struct sos_chardev_ops dev_zero_fs_ops;
 
 
 /** Helper function to insert the given physical page in the list of
     physical pages used for shared anonymous mappings */
 static sos_ret_t insert_anonymous_physpage(struct zero_mapped_resource *mr,
                                            sos_paddr_t ppage_paddr,
                                            sos_uoffset_t page_id);
 
 
 /** Helper function to insert the given physical page in the list of
     physical pages used for shared anonymous mappings */
 static sos_paddr_t lookup_anonymous_physpage(struct zero_mapped_resource *mr,
                                              sos_uoffset_t page_id);
 
 
 sos_ret_t sos_dev_zero_subsystem_setup()
 {
   sos_ret_t retval;
 
   cache_of_zero_mapped_pages =
     sos_kmem_cache_create("shared anonymous mappings",
                           sizeof(struct zero_mapped_page),
                           1, 0,
                           SOS_KSLAB_CREATE_MAP | SOS_KSLAB_CREATE_ZERO);
   if (! cache_of_zero_mapped_pages)
     return -SOS_ENOMEM;
 
   retval = sos_chardev_register_class(SOS_CHARDEV_ZERO_MAJOR,
                                       & dev_zero_fs_ops,
                                       NULL);
   if (SOS_OK != retval)
     {
       sos_kmem_cache_destroy(cache_of_zero_mapped_pages);
       return retval;
     }
 
   return SOS_OK;
 }
 
 
 /** Called after the virtual region has been inserted inside its
     address space */
 static void zero_ref(struct sos_umem_vmm_vr * vr)
 {
   /* Retrieve the 'zero' structure associated with the mapped resource */
   struct zero_mapped_resource * zero_resource;
   zero_resource
     = (struct zero_mapped_resource*)
     sos_umem_vmm_get_mapped_resource_of_vr(vr)->custom_data;
   
   /* Increment ref counter */
   zero_resource->ref_cnt ++;
 }
 
 
 /** Called when the virtual region is removed from its address
     space */
 static void zero_unref(struct sos_umem_vmm_vr * vr)
 {
   /* Retrieve the 'zero' structure associated with the mapped resource */
   struct zero_mapped_resource * zero_resource;
   zero_resource
     = (struct zero_mapped_resource*)
     sos_umem_vmm_get_mapped_resource_of_vr(vr)->custom_data;
 
   /* Decrement ref coutner */
   SOS_ASSERT_FATAL(zero_resource->ref_cnt > 0);
   zero_resource->ref_cnt --;
 
   /* Free the resource if it becomes unused */
   if (zero_resource->ref_cnt == 0)
     {
       /* Delete the list of anonymous shared mappings */
       struct zero_mapped_page *zmp;
       list_collapse(zero_resource->list_mapped_pages, zmp)
         {
           /* Unreference the underlying physical page */
           sos_physmem_unref_physpage(zmp->ppage_paddr);
           sos_kfree((sos_vaddr_t)zmp);
         }
 
       sos_kfree((sos_vaddr_t)zero_resource);
     }
 }
 
 
 /** MOST IMPORTANT callback ! Called when a thread page faults on the
     resource's mapping */
 static sos_ret_t zero_page_in(struct sos_umem_vmm_vr * vr,
                               sos_uaddr_t uaddr,
                               sos_bool_t write_access)
 {
   sos_ret_t retval = SOS_OK;
   sos_paddr_t ppage_paddr;
   sos_uoffset_t required_page_id;
   struct zero_mapped_resource * zero_resource;
   sos_ui32_t vr_prot, vr_flags;
 
   /* Retrieve the 'zero' structure associated with the mapped resource */
   zero_resource
     = (struct zero_mapped_resource*)
     sos_umem_vmm_get_mapped_resource_of_vr(vr)->custom_data;
 
   /* Retrieve access rights/flags of the VR */
   vr_prot  = sos_umem_vmm_get_prot_of_vr(vr);
   vr_flags = sos_umem_vmm_get_flags_of_vr(vr);
 
   /* Identifies the page in the mapping that's being paged-in */
   required_page_id = SOS_PAGE_ALIGN_INF(uaddr)
     - sos_umem_vmm_get_start_of_vr(vr)
     + sos_umem_vmm_get_offset_in_resource(vr);
 
   /* For shared mappings, check if there is a page already mapping the
      required address */
   if (vr_flags & SOS_VR_MAP_SHARED)
     {
       ppage_paddr = lookup_anonymous_physpage(zero_resource, required_page_id);
       if (NULL != (void*)ppage_paddr)
         {
           retval = sos_paging_map(ppage_paddr,
                                   SOS_PAGE_ALIGN_INF(uaddr),
                                   TRUE,
                                   vr_prot);
 
           return retval;
         }
     }
 
   /* For write accesses, directly maps a new page. For read accesses,
      simply map in the zero_page (and wait for COW to handle the next
      write accesses) */
   if (write_access)
     {
       /* Allocate a new page for the virtual address */
       ppage_paddr = sos_physmem_ref_physpage_new(FALSE);
       if (! ppage_paddr)
         return -SOS_ENOMEM;
 
       retval = sos_paging_map(ppage_paddr,
                               SOS_PAGE_ALIGN_INF(uaddr),
                               TRUE,
                               vr_prot);
       if (SOS_OK != retval)
         {
           sos_physmem_unref_physpage(ppage_paddr);
           return retval;
         }
       
       memset((void*)SOS_PAGE_ALIGN_INF(uaddr), 0x0, SOS_PAGE_SIZE);
 
       /* For shared mappings, add the page in the list of shared
          mapped pages */
       if (vr_flags & SOS_VR_MAP_SHARED)
         insert_anonymous_physpage(zero_resource, ppage_paddr,
                                   required_page_id);
 
       sos_physmem_unref_physpage(ppage_paddr);
     }
   else
     {
       /* Map-in the zero page in READ ONLY whatever the access_rights
          or the type (shared/private) of the VR to activate COW */
       retval = sos_paging_map(sos_zero_physpage,
                               SOS_PAGE_ALIGN_INF(uaddr),
                               TRUE,
                               SOS_VM_MAP_PROT_READ);
     }
 
   return retval;
 }
 
 
 /** The callbacks for a mapped /dev/zero resource */
 static struct sos_umem_vmm_vr_ops zero_ops = (struct sos_umem_vmm_vr_ops)
 {
   .ref     = zero_ref,
   .unref   = zero_unref,
   .page_in = zero_page_in,
   .unmap   = NULL
 };
 
 
 /** The callback that gets called when the resource gets mapped */
 static sos_ret_t zero_mmap(struct sos_umem_vmm_vr *vr)
 {
   return sos_umem_vmm_set_ops_of_vr(vr, &zero_ops);
 }
 
 
 /** The function responsible for mapping the /dev/zero resource in
     user space */
 sos_ret_t sos_dev_zero_map(struct sos_umem_vmm_as * dest_as,
                            sos_uaddr_t *uaddr,
                            sos_size_t size,
                            sos_ui32_t access_rights,
                            sos_ui32_t flags)
 {
   sos_ret_t retval;
   struct zero_mapped_resource * zero_resource;
 
   zero_resource
     = (struct zero_mapped_resource*) sos_kmalloc(sizeof(*zero_resource), 0);
   if (! zero_resource)
     return -SOS_ENOMEM;
 
   memset(zero_resource, 0x0, sizeof(*zero_resource));
   zero_resource->mr.allowed_access_rights 
     = SOS_VM_MAP_PROT_READ
     | SOS_VM_MAP_PROT_WRITE
     | SOS_VM_MAP_PROT_EXEC;
   zero_resource->mr.flags         |= SOS_MAPPED_RESOURCE_ANONYMOUS;
   zero_resource->mr.custom_data    = zero_resource;
   zero_resource->mr.mmap           = zero_mmap;
 
   retval = sos_umem_vmm_map(dest_as, uaddr, size,
                             access_rights, flags,
                             &zero_resource->mr, 0);
   if (SOS_OK != retval)
     {
       sos_kfree((sos_vaddr_t)zero_resource);
       return retval;
     }
 
   return SOS_OK;
 }
 
 
 static sos_ret_t insert_anonymous_physpage(struct zero_mapped_resource *mr,
                                            sos_paddr_t ppage_paddr,
                                            sos_uoffset_t page_id)
 {
   struct zero_mapped_page * zmp
     = (struct zero_mapped_page*)sos_kmem_cache_alloc(cache_of_zero_mapped_pages,
                                                      0);
   if (! zmp)
     return -SOS_ENOMEM;
 
   zmp->page_id     = page_id;
   zmp->ppage_paddr = ppage_paddr;
 
   list_add_head(mr->list_mapped_pages, zmp);
   sos_physmem_ref_physpage_at(ppage_paddr);
   return SOS_OK;
 }
 
 
 static sos_paddr_t lookup_anonymous_physpage(struct zero_mapped_resource *mr,
                                              sos_uoffset_t page_id)
 {
   struct zero_mapped_page * zmp;
   int nb_elts;
 
   list_foreach_forward(mr->list_mapped_pages, zmp, nb_elts)
     {
       if (zmp->page_id == page_id)
         return zmp->ppage_paddr;
     }
   
   return (sos_paddr_t)NULL;
 }
 
 /*
  * /dev/zero character device FS operations
  */
 
 static sos_ret_t dev_zero_fs_open(struct sos_fs_node        * fsnode,
                                   struct sos_fs_opened_file * of,
                                   void * chardev_class_custom_data)
 {
   /* Make sure the device instance is known to the driver */
   if ( (SOS_CHARDEV_NULL_MINOR != fsnode->dev_id.device_instance)
        && (SOS_CHARDEV_ZERO_MINOR != fsnode->dev_id.device_instance) )
     return -SOS_ENODEV;
 
   return SOS_OK;
 }
 
 
 static sos_ret_t dev_zero_fs_seek(struct sos_fs_opened_file *this,
                                   sos_lsoffset_t offset,
                                   sos_seek_whence_t whence,
                                   /* out */ sos_lsoffset_t * result_position)
 {
   /* Artificiallly update the position in the "file" */
   sos_lsoffset_t ref_offs;
 
   *result_position = this->position;
   switch (whence)
     {
     case SOS_SEEK_SET:
       ref_offs = 0;
       break;
 
     case SOS_SEEK_CUR:
       ref_offs = this->position;
       break;
 
     case SOS_SEEK_END:
       return -SOS_ENOSUP;
       break;
 
     default:
       return -SOS_EINVAL;
     }
 
   if (offset < -ref_offs)
     return -SOS_EINVAL;
   
   this->position = ref_offs + offset;
   *result_position = this->position;
   return SOS_OK;
 }
 
 
 static sos_ret_t dev_zero_fs_read(struct sos_fs_opened_file *this,
                                   sos_uaddr_t dest_buf,
                                   sos_size_t * /* in/out */len)
 {
   struct sos_fs_node * fsnode = sos_fs_nscache_get_fs_node(this->direntry);
   sos_size_t offs, rdlen;
 
   /* Reading /dev/null returns immediately */
   if (SOS_CHARDEV_NULL_MINOR == fsnode->dev_id.device_instance)
     {
       *len = 0;
       return SOS_OK;
     }
 
   /* ZERO the destination buffer using the zero page (by page_size
      increments) */
   for (rdlen = offs = 0 ; offs < *len ; offs += SOS_PAGE_SIZE)
     {
       sos_ret_t retval;
       sos_size_t memcpy_len = SOS_PAGE_SIZE;
       if (offs + memcpy_len > *len)
         memcpy_len = *len - offs;
       
       retval = sos_memcpy_to_user(dest_buf + offs, sos_zero_kernelpage,
                                   memcpy_len);
       if (retval < 0)
         break;
 
       rdlen += retval;
       if (retval != (sos_ret_t)memcpy_len)
         break;
     }
 
   /* Artificiallly update the position in the "file" */
   *len = rdlen;
   this->position += rdlen;
   return SOS_OK;
 }
 
 
 static sos_ret_t dev_zero_fs_write(struct sos_fs_opened_file *this,
                                    sos_uaddr_t src_buf,
                                    sos_size_t * /* in/out */len)
 {
   /* Artificiallly update the position in the "file" */
   this->position += *len;
   return SOS_OK;
 }
 
 
 static sos_ret_t dev_zero_fs_mmap(struct sos_fs_opened_file *this,
                                   sos_uaddr_t *uaddr, sos_size_t size,
                                   sos_ui32_t access_rights,
                                   sos_ui32_t flags,
                                   sos_luoffset_t offset)
 {
   return sos_dev_zero_map(sos_process_get_address_space(this->owner),
                           uaddr, size, access_rights, flags);
 }
 
 
 static struct sos_chardev_ops dev_zero_fs_ops
   = (struct sos_chardev_ops) {
     .open  = dev_zero_fs_open,
     .close = NULL,
     .seek  = dev_zero_fs_seek,
     .read  = dev_zero_fs_read,
     .write = dev_zero_fs_write,
     .mmap  = dev_zero_fs_mmap,
     .fcntl = NULL,
     .ioctl = NULL
   };