diff --git a/xen/arch/x86/x86_32/entry.S b/xen/arch/x86/x86_32/entry.S
index 12e51f1..2069265 100644
--- a/xen/arch/x86/x86_32/entry.S
+++ b/xen/arch/x86/x86_32/entry.S
@@ -706,7 +706,7 @@ ENTRY(hypercall_table)
         .long do_domctl
         .long do_kexec_op
         .long do_tmem_op
-	.long do_alloc_huge  /*39*A2K2 Hypercall*/
+	.long do_alloc_hugepage /*39*A2K2 Hypercall*/
         .rept __HYPERVISOR_arch_0-((.-hypercall_table)/4)
         .long do_ni_hypercall
         .endr
@@ -755,7 +755,7 @@ ENTRY(hypercall_args_table)
         .byte 1 /* do_domctl            */
         .byte 2 /* do_kexec_op          */
         .byte 1 /* do_tmem_op           */
-	.byte 1 /* do_alloc_huge	*/
+	.byte 3 /* do_alloc_huge	*/
         .rept __HYPERVISOR_arch_0-(.-hypercall_args_table)
         .byte 0 /* do_ni_hypercall      */
         .endr
diff --git a/xen/arch/x86/x86_64/entry.S b/xen/arch/x86/x86_64/entry.S
index 0925fbc..37de2fc 100644
--- a/xen/arch/x86/x86_64/entry.S
+++ b/xen/arch/x86/x86_64/entry.S
@@ -695,7 +695,7 @@ ENTRY(hypercall_table)
         .quad do_domctl
         .quad do_kexec_op
         .quad do_tmem_op
-	.quad do_alloc_huge /*a2k2 Hypercall for allocating hugepage from hugepool*/
+	.quad do_alloc_hugepage /*a2k2 Hypercall for allocating hugepage from hugepool*/
         .rept __HYPERVISOR_arch_0-((.-hypercall_table)/8)
         .quad do_ni_hypercall
         .endr
@@ -744,7 +744,7 @@ ENTRY(hypercall_args_table)
         .byte 1 /* do_domctl            */
         .byte 2 /* do_kexec             */
         .byte 1 /* do_tmem_op           */
-        .byte 1 /* do_alloc_huge        */
+        .byte 3 /* do_alloc_huge        */
         .rept __HYPERVISOR_arch_0-(.-hypercall_args_table)
         .byte 0 /* do_ni_hypercall      */
         .endr
--- a/xen/common/hugetable.c
+++ b/xen/common/hugetable.c
@@ -1,37 +1,184 @@
-#include <xen/hugetable.h>
+#include<xen/hugetable.h>
 
-int init_hugepages_pool(int order){
-  /*  	int k;
-	hugepage_cnt=0;
+static struct hugespace hugepool[20];
+static int start;
+/*
+This function is called from the setup.c file
+before domain is booted
+It will mark the pages as UNMARK which means this
+are freepages &not allocated to any domain.
+When pages is allocated to any domain id is stored 
+in hugepool info of that page.
+Importat: MFN's we got are from the 1-to-1
+mapping. For more info check config.h file. 
+ */
+int init_hugepages_pool(void){
+  
+    	int k;
+			
 	for(k=0;k<HUGEPAGE_POOL_SIZE;k++)
    	{ 
-    		hugepool[k].huge_vir_add = alloc_xenheap_pages(9,0);   
-		//hugepool[k].pg= alloc_domheap_pages(NULL,order,0);
-		hugepool[k].order=order;
-//		printk("\na2k2:%p\n",page_to_virt(hugepool[k].pg));
-		if(hugepool[k].huge_vir_add==NULL){
+		hugepool[k].mark=UNMARK_HUGEPAGE;
+		hugepool[k].order=9;
+    		hugepool[k].pg = alloc_domheap_pages(NULL,hugepool[k].order,0);
+		hugepool[k].virt=page_to_virt(hugepool[k].pg);
+		hugepool[k].mfn= page_to_mfn(hugepool[k].pg);
+		hugepool[k].pfn= pfn_to_paddr(hugepool[k].mfn);
+		printk("\na2k2: Virt_addr:%p   MFN:%lx  PFN:%lx\n",hugepool[k].virt,hugepool[k].mfn,hugepool[k].pfn);
+		
+		if(hugepool[k].virt==NULL){
 		  printk("\na2k2::Hugepages creation failed at %d\n",k);
   		  return 0;
 		}
 	}
-	printk("\na2k2::Hugepages pool created successfully\n");  */
+	printk("\na2k2::Hugepages pool created successfully\n");  
+	return 1;   
+	
+}
+/*
+int init_hugepages_pool_dom0(struct domain * dom0){
+    	int k;
+			
+	for(k=0;k<HUGEPAGE_POOL_SIZE;k++)
+   	{ 
+    		hugepool[k].pg = alloc_domheap_pages(dom0,9,0);
+		hugepool[k].virt=page_to_virt(hugepool[k].pg);
+		hugepool[k].mfn= page_to_mfn(hugepool[k].pg);
+		hugepool[k].pfn= pfn_to_paddr(hugepool[k].mfn);
+		printk("\na2k2: Virt_addr:%p   MFN:%lx  PFN:%lx\n",hugepool[k].virt,hugepool[k].mfn,hugepool[k].pfn);
+		
+		if(hugepool[k].virt==NULL){
+		  printk("\na2k2::Hugepages creation failed at %d\n",k);
+  		  return 0;
+		}
+	}
+	printk("\na2k2::Hugepages pool created successfully\n");  
 	return 1;   
 }
 
-/*EXPORT unsigned long  do_alloc_huge(int op){
-    
-  
-    return 1UL;
-}*/
+int reseve_hugepages_dom0(struct domain *dom0){
+    	int k;
+			
+	for(k=0;k<HUGEPAGE_POOL_SIZE;k++)
+   	{ 
+	  share_xen_page_with_guest(hugepool[k].pg,dom0,XENSHARE_writable);
+	  printk("\na2k2:Allocating : %d",k);
+	}
+	printk("\na2k2::Hugepages pool allocated to dom 0 successfully\n");  
+	return 1;   
+}
 
+void dom0_hugepages_pool(void){
+    	int k;
+			
+	for(k=0;k<HUGEPAGE_POOL_SIZE;k++)
+   	{ 
+    		printk("\na2k2: Mapping after dom 0 Virt_addr:%p   MFN:%lx  PFN:%lx\n",hugepool[k].virt,hugepool[k].mfn,hugepool[k].pfn);
+		
+		if(hugepool[k].virt==NULL){
+		  printk("\na2k2::Hugepages mapping failed at %d\n",k);
+		}
+	}
+	printk("\na2k2::Hugepages pool mapped to domain 0 successfully\n");  
+}
+*/
 
- unsigned long do_alloc_huge(int op){
-  if(op==MASK_HUGE_PAGE){
-  //  alloc_hugepage_from_pool(1,NULL);
+/*
+This function will get the pages from the pool 
+& will mark as MARKPAGES
+start is for quick accessing the next free pages index
+ */
+unsigned long  alloc_hugepage_from_pool(struct domain *d)
+{
+  
+      int k,flag=0;
+      printk("\na2k2:In alloc_hugepage_from_pool\n");
+      for(k=start;k<HUGEPAGE_POOL_SIZE;k++)
+      {
+	
+	if(hugepool[k].mark==UNMARK_HUGEPAGE)
+	{
+	  start=k;
+	  if(d!=NULL)
+	  flag=assign_pages(d,hugepool[k].pg,hugepool[k].order,0);
+	  /*assign_pages is for security
+	    
+	   */  
+	  if(flag==0)
+	    {
+	      //hugepool[k].domain_id=d->domain_id;  
+	    hugepool[k].mark=MARK_HUGEPAGE;
+	    printk("\na2k2::k = %d %sreturns %lx\n",k,__FUNCTION__,hugepool[k].mfn);
+	    return hugepool[k].mfn;
+	    }
+	    else
+	    {
+	      printk("\na2k2:Bad assign.\n");
+	      return 0UL;
+	    }
+	}
+      }
+	  printk("\na2k2:All huge pages allocated.\n");
+    	  return 0UL;
+}
+/*
+This functions will free the pages from the hugepool
+domain will pass the mfn to this function with order
+After passing security issues free call will be successful
+Free pages from the pool are markes as UNMARKED
+ */
+int free_hugepage_from_pool(struct domain *d, long mfn,int order)
+{
+  
+      int k,i;
+      
+      for(k=0;k<HUGEPAGE_POOL_SIZE;k++)
+      {
+	
+	if(hugepool[k].mark==MARK_HUGEPAGE&&hugepool[k].mfn==mfn&&hugepool[k].domain_id==d->domain_id&&hugepool[k].order==order)
+	{
+	  for ( i = 0; i < (1 << order); i++ )
+	  {
     
+            page_list_del2(hugepool[k].pg, &d->page_list, &d->arch.relmem_list);
+	  }
+
+	  d->tot_pages -= 1 << order;
+	  hugepool[k].mark==UNMARK_HUGEPAGE;
+	  
+	  printk("\na2k2:Freed.\n");
+	  return 1;
+	}
+      }
+	  printk("\na2k2:Not freed.\n");
+	
+	return 0;
+}
+/*a2k2:This is the code for the hypercall
+for allocating & deallocating hugepages .
+op=19 alloc_hugepage_from_pool
+op=20 free_hugepages_from_pool
+TODO:
+op=21 set pte for age
+*/
+unsigned long
+do_alloc_hugepage(int op,unsigned long *ptep,unsigned long pte)
+{
+  unsigned long  mfn;
+  switch(op){
+    case 1:
+      return alloc_hugepage_from_pool(current->domain);
+    case 2:  
+      return free_hugepage_from_pool(current->domain,0,9);
+    case 3:
+      mfn=alloc_hugepage_from_pool(current->domain);
+      pte = pte & 0xF000000000000FFF;
+      pte = pte | mfn << 12;
+      printk("\na2k2::ptp = %lx \n",pte);
+      //*ptep = pte;
+      printk("\na2k2::ptp = %lx \n",*ptep);
+      return pte;  
+      break;
   }
-  else if(op==UMASK_HUGE_PAGE){
-    //free_hugepages_from_pool(NULL); 
-  }
-  return 0UL;
+  return 0;
 }
--- a/xen/include/public/xen.h
+++ b/xen/include/public/xen.h
@@ -93,7 +93,7 @@ DEFINE_XEN_GUEST_HANDLE(xen_pfn_t);
 #define __HYPERVISOR_domctl               36
 #define __HYPERVISOR_kexec_op             37
 #define __HYPERVISOR_tmem_op              38
-#define __HYPERVISOR_alloc_huge		  39	
+#define __HYPERVISOR_alloc_hugepage		  39	
 /* Architecture-specific hypercall definitions. */
 #define __HYPERVISOR_arch_0               48
 #define __HYPERVISOR_arch_1               49
diff --git a/xen/include/xen/compile.h b/xen/include/xen/compile.h
index 3a28a2b..0ee0659 100644
--- a/xen/include/xen/compile.h
+++ b/xen/include/xen/compile.h
@@ -1,6 +1,6 @@
-#define XEN_COMPILE_DATE	"Sat Jan 29 16:12:07 IST 2011"
-#define XEN_COMPILE_TIME	"16:12:07"
-#define XEN_COMPILE_BY		"ashwin"
+#define XEN_COMPILE_DATE	"Thu Feb 10 12:02:37 IST 2011"
+#define XEN_COMPILE_TIME	"12:02:37"
+#define XEN_COMPILE_BY		"root"
 #define XEN_COMPILE_DOMAIN	"wildfire"
 #define XEN_COMPILE_HOST	"ashwin.wildfire"
 #define XEN_COMPILER		"gcc version 4.4.4 20100503 (Red Hat 4.4.4-2) (GCC) "
diff --git a/xen/include/xen/hugetable.h b/xen/include/xen/hugetable.h
old mode 100755
new mode 100644
index e2ae2b2..b7f4735
--- a/xen/include/xen/hugetable.h
+++ b/xen/include/xen/hugetable.h
@@ -1,26 +1,33 @@
 #ifndef __HUGETABLE_H__
 #define __HUGETABLE_H__
 #define HUGEPAGE_POOL_SIZE 20
-#define MASK_HUGE_PAGE 1
-#define UMASK_HUGE_PAGE 0
+#define MARK_HUGEPAGE 1
+#define UNMARK_HUGEPAGE 0
+#define ALLOCATE_HUGEPAGE 1
+#include<xen/sched.h>
+
 /*this struct is defined by team a2k2
  * huge_ref_cnt id for counting number of references
  * huge_mfn will give the mfn number of hugepage in RAM
  * order field by default is 9 but can be changed for future scope
  * domain_id will store the domain id whom the huge page is allocated
  */
-/*struct hugespace{
-  unsigned int mask;
+
+struct hugespace{
+  int mark;
   unsigned int huge_ref_cnt;
-  unsigned int huge_mfn;
+  unsigned long mfn;
+  unsigned long pfn;
   unsigned int order;
-  unsigned int domain;
+  unsigned int domain_id;
   struct page_info *pg;
-  void *huge_vir_add;  
-  }huge_pool[20];*/
-extern int hugepage_cnt;
-extern unsigned long  do_alloc_huge(int op);
-extern int init_hugepages_pool(int);
+  void *virt;  
+};
+
+//extern struct hugespace hugepool[20];
 
+extern int init_hugepages_pool(void);
+extern unsigned long  alloc_hugepage_from_pool(struct domain *d);
+extern int free_hugepage_from_pool(struct domain *d, long mfn,int order);
+extern unsigned long do_alloc_hugepage(int op,unsigned long * ptep,unsigned long pte);
 #endif
- 
diff --git a/xen/include/xen/hypercall.h b/xen/include/xen/hypercall.h
index db4a2ac..8123315 100644
--- a/xen/include/xen/hypercall.h
+++ b/xen/include/xen/hypercall.h
@@ -129,7 +129,8 @@ do_xenoprof_op(int op, XEN_GUEST_HANDLE(void) arg);
  * 
  **/
 extern unsigned long
-do_alloc_huge(int op);
+do_alloc_hugepage(int op,unsigned long *ptep,unsigned long pte);
+