xref: /third_party/ltp/testcases/kernel/device-drivers/include/includeTest.c

/*
 *
 *   Copyright (c) International Business Machines  Corp., 2001
 *
 *   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *

 * This test is meant to hit
 * many of the inline functions
 * in various include files.
 *
 * Author: David Cruz <cruzd@us.ibm.com>
 * Module: includeTest
 *
 */

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/pm.h>
#include <linux/genhd.h>
#include <linux/in.h>
#include <asm/types.h>
#include <linux/lockd/bind.h>
#include <acpi/acpi_drivers.h>
#include <linux/nfsd/nfsfh.h>
#include <linux/sunrpc/auth.h>
#include <linux/sunrpc/cache.h>
#include <linux/sunrpc/svc.h>
#include <linux/sunrpc/xdr.h>
#include <linux/sunrpc/timer.h>
#include <video/vga.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/lockd/lockd.h>
#include <linux/lockd/nlm.h>
#include <linux/nfsd/export.h>
#include <asm/uaccess.h>
#include "includeTest.h"

MODULE_AUTHOR("David Cruz <cruzd@us.ibm.com>");
MODULE_DESCRIPTION(TEST_DRIVER_NAME);
MODULE_LICENSE("GPL");

static int test_ioctl(struct inode *, struct file *, unsigned int,
		      unsigned long);
static int test_open(struct inode *, struct file *);
static int test_close(struct inode *, struct file *);
static void test_acpi(void);
static void test_vga(void);
static void test_sunrpc_auth(void);
static void test_nfsfh(void);
static void test_lockd(void);
static void test_sunrpc_cache(void);
static void test_sunrpc_svc(void);
static void test_sunrpc_timer(void);

static int Major = 0;

static struct block_device_operations bdops = {
open:	test_open,
release:test_close,
ioctl:	test_ioctl,
};

static char genhd_flags = 0;
static struct gendisk *gd_ptr;
static struct pm_dev *ltp_pm_dev = NULL;

static int test_open(struct inode *ino, struct file *f)
{
	printk("device open\n");
	return 0;
}

static int test_close(struct inode *ino, struct file *f)
{
	printk("device closed\n");
	return 0;
}

static int test_ioctl(struct inode *ino, struct file *f, unsigned int cmd,
		      unsigned long l)
{

	int rc = 0;		//return code
	int arg;

	printk("Entered the ioctl call.\n");

	if (copy_from_user(&arg, (void *)l, sizeof(int))) {
		//bad address
		return (-EFAULT);
	}

	switch (cmd) {

	case OPTION1:
		option1();
		break;
	default:
		printk("Mismatching ioctl command\n");
		break;
	}

	//0 by default
	return rc;
}

static void option1(void)
{
	printk("Module option 1 chosen\n");
}

static int ltp_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
{
	return 0;
}

static int test_init_module(void)
{

	int rc;

	printk("starting module\n");

	ltp_pm_dev = pm_register(PM_UNKNOWN_DEV, 0, ltp_pm_callback);
	rc = register_blkdev(INCLUDEMAJOR, DEVICE_NAME);

	printk("BLK INC - result =%d major %d\n", rc, INCLUDEMAJOR);

	if (rc < 0) {
		printk("Failed to register device.\n");
		return rc;
	}

	gd_ptr = kmalloc(sizeof(struct gendisk *), GFP_KERNEL);
	if (!gd_ptr) {
		printk(KERN_ALERT "ERROR getting memory !!!\n");
		return 0;
	}

	printk("major = %d\n", Major);
	gd_ptr = alloc_disk(1);
	printk(KERN_ALERT "gd_ptr after alloc = %p \n", gd_ptr);
	gd_ptr->major = INCLUDEMAJOR;
	gd_ptr->first_minor = 0;
	gd_ptr->fops = &bdops;
//      gd_ptr->minor_shift= MINOR_SHIFT_BITS;
	gd_ptr->driverfs_dev = NULL;
	gd_ptr->capacity = MAX_NUM_DISKS;
//      gd_ptr->disk_de = NULL;
	gd_ptr->flags = genhd_flags;

	sprintf(gd_ptr->disk_name, DEVICE_NAME);
	add_disk(gd_ptr);

	printk("major = %d\n", Major);

	test_acpi();
	test_vga();
	test_lockd();
	test_sunrpc_auth();
	test_nfsfh();
	test_sunrpc_cache();
	test_sunrpc_svc();
	test_sunrpc_timer();
	printk("finished module\n");

	return 0;
}

static void test_exit_module(void)
{

	int rc;

	pm_unregister(ltp_pm_dev);
	put_disk(gd_ptr);
	del_gendisk(gd_ptr);

	rc = unregister_blkdev(INCLUDEMAJOR, DEVICE_NAME);

	if (rc < 0) {
		printk("unregister failed %d\n", rc);
	} else {
		printk("unregister success\n");
	}
}

static void test_acpi(void)
{
	u32 flag;

	for (flag = 0; flag <= 4; flag++)
		acpi_set_debug(flag);

	printk("finished acpi test\n");
}

static void test_sunrpc_auth(void)
{
	struct rpc_cred cred;

	atomic_set(&(cred.cr_count), 0);
	get_rpccred(&cred);
	printk("finished auth test\n");
}

static void test_vga(void)
{

	unsigned short vgaS = 0;
	int i = 0;
	vga_r((caddr_t) i, vgaS);
	printk("finished vga test\n");
}

static void test_nfsfh(void)
{
	dev_t dev = 0;
	u32 unfs = 0, u32ptr[2];
	ino_t ino = 0;
	struct svc_fh A1;
	int i = 20;

	u32_to_dev_t((__u32) unfs);
	ino_t_to_u32(ino);
	u32_to_ino_t((__u32) unfs);
	mk_fsid_v0(u32ptr, dev, ino);
	mk_fsid_v1(u32ptr, unfs);
	SVCFH_fmt(&A1);
	fh_init(&A1, i);
	fh_lock(&A1);
	fh_unlock(&A1);
	printk("finished nfsfh test\n");
}

static void test_lockd(void)
{

	struct nlm_file file;
	struct sockaddr_in sin1, sin2;
	struct file_lock fl1, fl2;

	nlm_compare_locks(&fl1, &fl2);
	nlm_cmp_addr(&sin1, &sin2);
	nlmsvc_file_inode(&file);
	printk("finished lockd test\n");
}

static void test_sunrpc_cache(void)
{
	struct cache_head head;
	struct cache_detail detail;

	cache_get(&head);
	cache_put(&head, &detail);
	printk("finished cache test\n");
}

static void test_sunrpc_svc(void)
{
	u32 val;
	struct svc_rqst rqstp;
	char name[50];
	struct iovec iov;
	int bits = 0, bits2 = 0;
	rqstp.rq_resused = 1;

	svc_getu32(&iov);
//      svc_putu32(&iov, val);

	xdr_argsize_check(&rqstp, &val);
	xdr_ressize_check(&rqstp, &val);
	svc_take_page(&rqstp);
	svc_pushback_allpages(&rqstp);
	svc_pushback_unused_pages(&rqstp);
	svc_free_allpages(&rqstp);
	hash_str(name, bits);
	hash_mem(name, bits, bits2);
	printk("finished svc test\n");

}

static void test_sunrpc_timer()
{
	struct rpc_rtt rt;

	rpc_inc_timeo(&rt);
	rpc_clear_timeo(&rt);
	rpc_ntimeo(&rt);
	printk("finished timer test\n");
}

module_init(test_init_module)
    module_exit(test_exit_module)