while(tmp->vm_next && tmp->vm_next != start ){//&& count < 200){
        ... // local variable declarations and checks
           page = get_page_from_addr(tmp,addr);
	   my_set_pte(tmp, addr);
	...
           addr += PAGE_SIZE;
	...
       tmp = tmp->vm_next;
   }

int my_set_pte(struct vm_area_struct *vma,unsigned long address)
{
     unsigned long pfn;
     pgd_t *pgd;
     pud_t *pud;
     pmd_t *pmd;
     pte_t *ptep, pte, temp_pte;
     spinlock_t *ptl;
     struct page *page=NULL;
     struct mm_struct *mm = vma->vm_mm;
     pgd = pgd_offset(mm, address);

     if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd)))
                goto out;
     pud = pud_offset(pgd, address);
     if (pud_none(*pud))
                goto out;
     if ((pud_val(*pud) & _PAGE_PSE) && vma->vm_flags & VM_HUGETLB) {
                page = follow_huge_PUD(mm, address, pud);
                goto out;
     }
    if (unlikely(pud_bad(*pud)))
                goto out;

    pmd = pmd_offset(pud, address);
    if (pmd_none(*pmd))
                goto out;
    if ((pmd_val(*pmd) & _PAGE_PSE) && vma->vm_flags & VM_HUGETLB) {
                page = follow_huge_PMD(mm, address, pmd);
                goto out;
    }
    if (pmd_trans_huge(*pmd)){
                spin_lock(&mm->page_table_lock);
                if (likely(pmd_trans_huge(*pmd))) {
                                page = follow_trans_huge_PMD(mm, address,
                                                             pmd);
                                spin_unlock(&mm->page_table_lock);
                                goto out;
                } else
                        spin_unlock(&mm->page_table_lock);

    }
    if (unlikely(pmd_bad(*pmd)))
                goto out;

    ptep = pte_offset_map_lock(mm, pmd, address, &ptl);
    pte = *ptep;
    if (!pte_present(pte))
             goto no_page;
    pfn = pte_pfn(pte);
    if(!pfn_valid(pfn))
            goto bad_page;
    page = pfn_to_page(pfn);
    if( (pte_flags(pte) & (_PAGE_PRESENT)) && !(pte_flags(pte) & (_PAGE_PROTNONE)))
    {

      // this if condition makes sure that before our kernel module makes any changes to a page,
     //the page is present and also its protection bit is not set

        flush_tlb_page(vma, address);
        // clear the present bit and set the prot bit and store this address in the array

        pte_unmap_unlock(ptep, ptl);
        // !? check: Is there a lock required to be taken here?? ?!

        temp_pte = pte_clear_flags(pte, _PAGE_PRESENT);

	set_pte(ptep, temp_pte);

        temp_pte = pte_set_flags(pte, _PAGE_PROTNONE);

	set_pte(ptep, temp_pte);

       arr[array_count].touched = 0;
       arr[array_count].addr = address;
       arr[array_count].pte = pte;
       array_count++;
	goto out;

    }

    if (unlikely(!page)) {
                if (page_to_pfn(ZERO_PAGE(0)) == pte_pfn(pte))
                        goto bad_page;
                page = pte_page(pte);
    }
    pte_unmap_unlock(ptep, ptl);
out:

    return 1;
bad_page:

    pte_unmap_unlock(ptep, ptl);
    return 1;
no_page:

	pte_unmap_unlock(ptep, ptl);
     return 1;


}