/*
    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


    ChangeLog:
    14 jul 2005 - Fixed race condition and prints results on exit

*/

#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>

#include <linux/version.h>

#ifndef MB
#define MB 42
#endif
#define PAGES (MB*256)

struct page *p[PAGES];

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

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);
static atomic_t kmemtest_quit = ATOMIC_INIT(0);

int kmemtest_thread(void *arg)
{
  int i,pass=0,errors=0;
  struct task_struct *curtask = current;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
  sigset_t blocked;
  daemonize("kmemtest");
  sigemptyset(&blocked);
  sigprocmask(SIG_SETMASK, &blocked, NULL);
#else
  daemonize();
#endif
  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(KERN_CRIT "kmemtest: kmap failed!\n");
	  complete_and_exit(&kmemtest_exited, 0);
	}
	if (memcmp(pa,page[parity(i&s1.hi)],4096))
	  printk(KERN_CRIT "kmemtest: 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)||atomic_read(&kmemtest_quit)) {
	kmemtest_cleanup();
	printk(KERN_NOTICE "kmemtest: found %d errors in %d passes of %dMB\n",errors,pass-1,MB);
	complete_and_exit(&kmemtest_exited, 0);
      }
      cond_resched();
    }
    memcpy(page+0,page+2,8192);
    s1=s2;
  }
}

static int __init init_kmemtest(void)
{
  int i;
  struct sysinfo si;

  si_meminfo(&si);
  if (PAGES >= si.totalram) return -ENOMEM;

  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) {
    void *pa;
    p[i]=alloc_page(GFP_HIGHUSER);
    if(!p[i]) {
      kmemtest_cleanup();
      return -ENOMEM;
    }
    pa=kmap(p[i]);
    if (!pa) {
      kmemtest_cleanup();
      return -ENOMEM;
    }
    memcpy(pa,page[parity(i&s1.hi)],4096);
    kunmap(p[i]);
    cond_resched();
  }

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

  printk(KERN_NOTICE "kmemtest: testing %dMB of memory\n",MB);
  return 0;
}

static void __exit exit_kmemtest(void)
{
  atomic_inc(&kmemtest_quit);
  wait_for_completion(&kmemtest_exited);
  kmemtest_cleanup();
}

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