/*
    kmemtest - a memory tester to run as a kernel thread under Linux
    Copyright (C) 2005  Kasper Dupont

    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
    with permission from the author 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 <linux/module.h>

#include <linux/pagemap.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/smp_lock.h>

#include <asm/uaccess.h>
#include <linux/random.h>

#define MB 1000
#define PAGES (MB*256)

struct page *p[PAGES];

struct seed {
  uint32_t hi;
  uint16_t lo;
  uint16_t in;
} s1, s2;

pid_t thread_pid = 0;

uint16_t page[4][2048];

void kmemtest_cleanup(void)
{
  int i;
  for (i=0;i<PAGES;++i)
    if (p[i]) {
      __free_page(p[i]);
      p[i]=NULL;
    }
}

int parity(uint32_t x)
{
  x^=x>>16;
  x^=x>>8;
  x^=x>>4;
  x^=x>>2;
  x^=x>>1;
  return x&1;
}

void init(uint16_t *p,uint16_t lo, uint16_t in)
{
  int i;
  for (i=0;i<2048;++i) p[i]=parity(i&lo)?~in:in;
}

static DECLARE_COMPLETION(kmemtest_exited);

int kmemtest_thread(void *arg)
{
  //sigset_t blocked;
  int i,pass=0,errors=0;
  struct task_struct *curtask = current;
  daemonize(/*"kmemtest"*/);
  //sigemptyset(&blocked);
  //sigprocmask(SIG_SETMASK, &blocked, NULL);
  set_user_nice(curtask, 19);
  while(1) {
    snprintf(curtask->comm,15,"kmemtest %d",++pass);
    get_random_bytes(&s2,8);
    init(page[2],s2.lo,s2.in);
    init(page[3],s2.lo,~s2.in);
    for (i=0;i<PAGES;++i) {
      if (p[i]) {
	void *pa=kmap(p[i]);
	if (!pa) {
	  printk("Bummer");
	  complete_and_exit(&kmemtest_exited, 0);
	}
	if (memcmp(pa,page[parity(i&s1.hi)],4096))
	  printk(KERN_CRIT "error on page %d (%d) - %d errors \n",
		 p[i]-mem_map,i,++errors);
	memcpy(pa,page[parity(i&s2.hi)+2],4096);
	kunmap(p[i]);
      }
      if (signal_pending(curtask)) {
	kmemtest_cleanup();
	thread_pid=0;
	complete_and_exit(&kmemtest_exited, 0);
      }
      cond_resched();
    }
    memcpy(page+0,page+2,8192);
    s1=s2;
  }
}

static int __init init_kmemtest(void)
{
  int i;
  memset(p,0,sizeof(p));

  init(page[0],s1.lo,s1.in);
  init(page[1],s1.lo,~s1.in);

  for (i=0;i<PAGES;++i) {
    p[i]=alloc_page(GFP_HIGHUSER);
    if (p[i]) {
      void *pa=kmap(p[i]);
      if (!pa) {
	kmemtest_cleanup();
	return -ENOMEM;
      }
      memcpy(pa,page[parity(i&s1.hi)],4096);
      kunmap(p[i]);
    }
  }

  thread_pid=kernel_thread(kmemtest_thread,NULL,0);
  if (thread_pid < 0) {
    printk(KERN_CRIT "kmemtest: kernel_thread failed\n");
    thread_pid=0;
    return -ENOMEM;
  }

  return 0;
}

static void __exit exit_kmemtest(void)
{
  kill_proc(thread_pid,SIGTERM,1);
  wait_for_completion(&kmemtest_exited);
  kmemtest_cleanup();
}

module_init(init_kmemtest)
module_exit(exit_kmemtest)
MODULE_LICENSE("GPL");