[Ltp-cvs] ltp/testcases/kernel/device-drivers/nls nlsTest.h,NONE,1.1 nlsTest.c,NONE,1.1 userBlockNLS.c,NONE,1.1 Makefile,NONE,1.1

[<mr...@us...>]

Update of /cvsroot/ltp/ltp/testcases/kernel/device-drivers/nls
In directory sc8-pr-cvs1:/tmp/cvs-serv26474

Added Files:
	nlsTest.h nlsTest.c userBlockNLS.c Makefile 
Log Message:
New testcases to execute the nls filesystem code in the kernel


--- NEW FILE: nlsTest.h ---
//nlsTest.h

#define MAG_NUM 'k'
#define MODULE_TEST_COMPONENT   0x00023000
#define OPTION1                 _IO(MAG_NUM, 1)
#define _COMPONENT              MODULE_TEST_COMPONENT
#define TEST_DRIVER_NAME        "nls test module"
#define DEVICE_NAME             "nlsTest"
#define DEV_PATH                "/dev"
#define NLS_DEVICE_PATH         DEV_PATH "/"
#define NLSMAJOR                253
#define MINOR_SHIFT_BITS        3
#define MAX_PARTITIONS          8
#define MAX_NUM_DISKS           3
#define DEV_NAME                "nlsTest"

typedef struct _nlsdev_cmd {
        u_int32_t cmd;
        u_int32_t status;
} nlsdev_cmd_t;

typedef enum nlsdev_ioctl_cmds_s {
        NLS_IOCTL_NUMBER = 0x5500
} nlsdev_ioctl_cmds_t;

#define NLSDEV_CMD              _IOR(NLSMAJOR, NLS_IOCTL_NUMBER, nlsdev_cmd_t**)

/*
 * function prototypes
 */

static void option1(void);


--- NEW FILE: nlsTest.c ---

#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/version.h>
#include <linux/string.h>
#include <linux/config.h>
#include <linux/nls.h>

#ifdef CONFIG_KMOD
#include <linux/kmod.h>
#endif

#include <linux/errno.h>
#include <linux/spinlock.h>
#include <asm/uaccess.h>
#include "nlsTest.h"

MODULE_AUTHOR("David Cruz <cr...@us...>");
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_nls_base(void);

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(NLSMAJOR, DEVICE_NAME);

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

        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",NLSMAJOR);
	gd_ptr = alloc_disk(1);
	printk(KERN_ALERT "gd_ptr after alloc = %p \n",gd_ptr);
	gd_ptr->major = NLSMAJOR;
	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);
	
	test_nls_base();
	
	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(NLSMAJOR, DEVICE_NAME);
		
        if(rc < 0) {
                printk("unregister failed %d\n",rc);
        }
        else {
                printk("unregister success\n");
        }
}

static void test_nls_base(void) {

	wchar_t p=0x20;
	__u8 s=0x01;
	int n=2;
	struct nls_table nls;
	char charset[20]="David";
	
	load_nls_default();
	register_nls(&nls);
	unload_nls(&nls);
	load_nls(charset);
	unregister_nls(&nls);
	utf8_mbtowc(&p, &s, n);
	utf8_mbstowcs(&p, &s, n);
	n=20;
	utf8_wctomb(&s, p, n);
	utf8_wcstombs(&s, &p, n);
}


module_init(test_init_module)
module_exit(test_exit_module)

--- NEW FILE: userBlockNLS.c ---
#include <stdio.h> 
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/kd.h>
#include <linux/errno.h>

#include "nlsTest.h"

int open_block_device(void);

int block_dev_handle = 0;      /* handle to nls test block device */

int main(int argc, char **argv)
{

    nlsdev_cmd_t  cmd = {0,0};
    int rc;

    rc = open_block_device();

    if (!rc) {

        block_dev_handle = open(DEVICE_NAME, O_RDWR);

        if (block_dev_handle < 0) {
            printf("ERROR: Open of device %s failed %d errno = %d\n", 
		DEVICE_NAME,block_dev_handle, errno);
        }
        else {
            rc = ioctl (block_dev_handle, NLSDEV_CMD, &cmd);

            printf("return from ioctl %d \n", rc);
        }

    } else {
        printf("ERROR: Create/open block device failed\n");
    }

    return 0;
}

int open_block_device()
{
    dev_t devt;
    struct stat statbuf;
    int rc;

    if (block_dev_handle == 0) {

        /* check for the /dev/ subdir, and create if it does not exist.
         *
         * If devfs is running and mounted on /dev, these checks will all pass,
         * so a new node will not be created.
         */

        devt = makedev(NLSMAJOR, 0);

        rc = stat(NLS_DEVICE_PATH, &statbuf);

	if (rc) {
            if (errno == ENOENT) {
                /* dev node does not exist. */
                rc = mkdir(NLS_DEVICE_PATH, (S_IFDIR | S_IRWXU |
                                                    S_IRGRP | S_IXGRP |
                                                    S_IROTH | S_IXOTH));
		
            } else {
                printf("ERROR: Problem with INC dev directory.  Error code from stat(
			) is %d\n\n", errno);
            }
        } else {
	    if (!(statbuf.st_mode & S_IFDIR)) {
                rc = unlink(NLS_DEVICE_PATH);
	        if (!rc) {
	             rc = mkdir(NLS_DEVICE_PATH, (S_IFDIR | S_IRWXU |
                                                    S_IRGRP | S_IXGRP |
                                                    S_IROTH | S_IXOTH));
                }
            }
        }

	/*
         * Check for the block_device node, and create if it does not
         * exist.
         */

        rc = stat(DEVICE_NAME, &statbuf);
        if (rc) {
	    if (errno == ENOENT) {
                /* dev node does not exist */
                rc = mknod(DEVICE_NAME, (S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP), devt);
            } else {
                printf("ERROR:Problem with block device node directory.  Error code form stat() is %d\n\n", errno);
            }

         } else {
	    /*
             * Device exists. Check to make sure it is for a
             * block device and that it has the right major and minor.
             */

            if ((!(statbuf.st_mode & S_IFBLK)) ||
                 (statbuf.st_rdev != devt)) {
                /* Recreate the dev node. */
                rc = unlink(DEVICE_NAME);
                if (!rc) {
                    rc = mknod(DEVICE_NAME, (S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP), devt);
                }
            }
        }

    }
    return rc;
}


--- NEW FILE: Makefile ---
#
# Makefile for GCOV profiling kernel module
#

#KERNELDIR := /usr/src/linux-2.5.66-gcov
CFLAGS := $(CFLAGS) -Wall

ifneq ($(KERNELRELEASE),)

obj-m	:= nlsTest.o
else
KDIR	:= /lib/modules/$(shell uname -r)/build
PWD	:= $(shell pwd)

default:
	$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
	gcc -Wall -o userBlockNLS userBlockNLS.c
#	$(MAKE) -C $(KERNELDIR) SUBDIRS=$(PWD) modules
endif

clean:
	rm -f nlsTest.o 2>/dev/null || true