Linux内核模块 – IOCTL用法返回ENOTTY

2019-06-23 12:38:28 阅读：965 来源： 互联网

我正在研究小内核模块.我试图使用IOCTL(在ioctl_add中),但是当我调用它时,我会在EN的底部检查它,这是在交换机中检查的.代码如下.有谁知道我做错了什么？

user.c的：

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <linux/ioctl.h>
#include <sys/stat.h>
#include <sys/poll.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

#define IOCTL_TYPE (100)
#define IOCTL_ADD (_IO(IOCTL_TYPE, 1))

void cleanup()
{
  if(f>=0) {
    close(f);
  }
}

int ioctl_add(int f)
{
    int ret;
    ret = ioctl(f, IOCTL_ADD);
    printf("Add \n");
    return ret;
}

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

        int fd;
        int *ptr;
        fd = open(argv[1], O_RDWR);

        if (fd < 0) {
                perror("error");
        }
        posix_memalign((void **)&ptr, 4096, 4096);
        * ptr = atoi(argv[2]); 
        write(fd, ptr, 4096);

        ioctl_add(fd);

        printf("data is %d\n", *ptr);  

        close(fd);

    switch(errno){
        case EBADF:
        printf("errno: EBADF \n");
        break;

        case EFAULT:
        printf("errno: EFAULT \n");
        break;

        case EINVAL:
        printf("errno: EINVAL \n");
        break;

        case ENOTTY:
        printf("errno: ENOTTY \n");
        break;

        default:
        printf("errno: none \n");

        return 0;
    }

    return 0;
}

的module.c：

#include <linux/kernel.h>  
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/sched.h>

#include <linux/device.h>
#include <linux/fs.h>
#include <linux/cdev.h>
//#include <linux/mm.h>
//#include <linux/config.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/poll.h>
#include <asm/io.h>
#include <asm/bitops.h>

#include <linux/ioctl.h>
#define IOCTL_TYPE (100)
#define IOCTL_ADD (_IO(IOCTL_TYPE, 1))

#include <linux/mm.h>
#include <linux/pagemap.h>


#define DEVICE_NAME "acc_priv"
MODULE_LICENSE("GPL v2");

int ress, tmp;
struct  page *page;
int    *myaddr;

ssize_t acc_read(struct file *filp,
           char __user *buf, size_t count,loff_t * off)
{
  printk (KERN_ALERT "Opened\n\r");
  return 0; 
}  

ssize_t acc_write(struct file *filp,
            const char __user *buf, size_t count,loff_t * off)
{

  printk (KERN_ALERT "Write\n\r");

  printk(KERN_INFO "%s\n", __FUNCTION__);
  down_read(&current->mm->mmap_sem);
  ress = get_user_pages(current, current->mm,(unsigned long)buf,1,1,1,&page,NULL);
        if (ress) {
                printk(KERN_INFO "Got mmaped.\n");
                myaddr = kmap(page);
                printk(KERN_INFO "%d\n", *myaddr);

                tmp = *myaddr;   

                tmp = tmp * 2;
                printk(KERN_INFO "the result of multiplying: %d\n", tmp);

                * myaddr = tmp;
                page_cache_release(page);
        }
        up_read(&current->mm->mmap_sem);
        return (0);
}


static int acc_open(struct inode *inode,
              struct file *file)
{
  printk(KERN_INFO "Opened inode:%p, file:%p\n", inode, file);
  return 0;
}


long acc_ioctl(struct file *filp,
         unsigned int cmd,unsigned long arg)
{
      if(cmd == IOCTL_ADD)
        printk(KERN_INFO "Do specified job \n");

      return 0;
{

int acc_release(struct inode *inode,
          struct file *file)
{

  printk (KERN_INFO "device_release(%p,%p)\n", inode, file);

  return 0;
}

struct file_operations Fops = {
  .owner=THIS_MODULE,
  .read=acc_read, 
  .write=acc_write,
  .open=acc_open,
  .unlocked_ioctl=acc_ioctl,
  .release=acc_release, 
};

dev_t my_dev=0;
struct cdev * my_cdev = NULL;
static struct class *class_acc_priv = NULL;


void  clean_up(void)
{

  if(my_dev && class_acc_priv) {
    device_destroy(class_acc_priv,my_dev);
  }
  if(my_cdev) {
    cdev_del(my_cdev);
    my_cdev=NULL;
  }
  if(my_dev) {
    unregister_chrdev_region(my_dev, 1);
  }
  if(class_acc_priv) {
    class_destroy(class_acc_priv);
    class_acc_priv=NULL;
  }
}


int init_acc_priv(void)
{
  int res=0;
  res=alloc_chrdev_region(&my_dev, 0, 1, DEVICE_NAME);
  if(res) {
    printk (KERN_ALERT "Alocation of the device number for %s failed\n",
            DEVICE_NAME);
    return res;
  };

  class_acc_priv = class_create(THIS_MODULE, "acc_class");
  if (IS_ERR(class_acc_priv)) {
    printk(KERN_ERR "Error creating rs_class.\n");
    res=PTR_ERR(class_acc_priv);
    goto err1;
  }

  my_cdev = cdev_alloc( );
  my_cdev->ops = &Fops;
  my_cdev->owner = THIS_MODULE;
  res=cdev_add(my_cdev, my_dev, 1);
  if(res) {
    printk (KERN_ALERT "Registration of the device number for %s failed\n",
            DEVICE_NAME);
    res=-EFAULT;
    goto err1;
  };

  device_create(class_acc_priv,NULL,my_dev,NULL,"acc_priv%d",MINOR(my_dev));
  printk (KERN_ALERT "%s The major device number is %d.\n",
      "Registeration is a success.",
      MAJOR(my_dev));
  return res;
 err1:
  clean_up();
  return res;
}
module_init(init_acc_priv);


void cleanup_acc_priv( void )
{
  clean_up();
}
module_exit(cleanup_acc_priv);

解决方法:

当32位应用程序在64位操作系统上运行时,它使用compat_ioctl syscall而不是unlocked_ioctl来执行ioctl命令.特殊系统调用的原因是ioctl参数的大小可能因64位和32位应用程序而异.

所以你需要实现.compat_ioctl文件操作.

标签：module,c-3,linux,kernel,ioctl
来源： https://codeday.me/bug/20190623/1270887.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Linux内核模块 – IOCTL用法返回ENOTTY