编写Linux内存驱动程序以将小写转换为大写

Question

I was doing an assignment to build a memory driver which can convert lowercase to uppercase in Linux. Linux will take the last byte through echo and cat. It was due already. I tried several approaches but all didn't succeed.

I did char upper = 'A' + (upper - 'a') or ASCII - 32 if (ASCII is between a and z). I tried to put the statement in either memory write or read. Neither work.

Here is the memory.c. Can anyone let me know what mistake I have committed to? I just make on change based on the sample code from my instructor.

/* Necessary includes for device drivers */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
#include <asm/system.h> /* cli(), *_flags */
#include <asm/uaccess.h> /* copy_from/to_user */


MODULE_LICENSE("Dual BSD/GPL");

/* Declaration of memory.c functions */
int memory_open(struct inode *inode, struct file *filp);
int memory_release(struct inode *inode, struct file *filp);
ssize_t memory_read(struct file *filp, char *buf, size_t count, loff_t *f_pos);
ssize_t memory_write(struct file *filp, char *buf, size_t count, loff_t *f_pos);
void memory_exit(void);
int memory_init(void);

/* Structure that declares the usual file */
/* access functions */
struct file_operations memory_fops =
{
  read: memory_read,
  write: memory_write,
  open: memory_open,
  release: memory_release
};

/* Declaration of the init and exit functions */
module_init(memory_init);
module_exit(memory_exit);

/* Global variables of the driver */
/* Major number */
int memory_major = 60;

/* Buffer to store data */
char *memory_buffer;



/* Memory Init Module */
int memory_init(void)
{
  int result;
  printk(KERN_ALERT "memory_init\n");

  /* Registering device */
  result = register_chrdev(memory_major, "memory", &memory_fops);
  if (result < 0) {
    printk(
      "<1>memory: cannot obtain major number %d\n", memory_major);
    return result;
  }

  /* Allocating memory for the buffer */
  memory_buffer = kmalloc(1, GFP_KERNEL);

  if(!memory_buffer)
  {
    memory_exit();
    return(-ENOMEM);
  }
  else
  {
    memset(memory_buffer, 0, 1);
    printk("<1>Inserting memory module\n");
    return 0;
  }
}



/* Memory Exit */
void memory_exit(void)
{

  printk("<1>Removing memory module\n");

  /* Freeing the major number */
  unregister_chrdev(memory_major, "memory");

  /* Freeing buffer memory */
  if (memory_buffer) {
    kfree(memory_buffer);
  }
}

/* Memory Open */
int memory_open(struct inode *inode, struct file *filp)
{
  printk(KERN_ALERT "memory_open\n");

  /* Success */
  return 0;
}

/* Memory Release */
int memory_release(struct inode *inode, struct file *filp)
{
  printk(KERN_ALERT "memory_release\n");

  /* Success */
  return 0;
}

/* Memory Read */
ssize_t memory_read(struct file *filp, char *buf,
                    size_t count, loff_t *f_pos)
{

  printk(KERN_ALERT "memory_read\n");
  /* Transfering data to user space */
  copy_to_user(buf,memory_buffer,1);  

  /* Changing reading position as best suits */
  if (*f_pos == 0)
  {
    *f_pos+=1;
    return 1;
  }
  else
  {
    return 0;
  }
}

/* Memory Write */
ssize_t memory_write( struct file *filp, char *buf,
                      size_t count, loff_t *f_pos)
{
  char *tmp;


  tmp=buf+count-1;
  copy_from_user(memory_buffer,tmp,1);
  char upper = 'A' + (upper - 'a'); // convert lower to upper case
  printk(KERN_ALERT "memory_write\n");

  return 1;
}

Answer 1

A few comments:

In your code for memory_write you are actually writing the new contents to memory before "calculating" the uppercase of the char. I said "calculating" because you are attempting to calculate the uppercase of something, but that something is neither defined nor used, so the compiler is probably discarding the line, I'm talking about this line:

char upper = 'A' + (upper - 'a'); // convert lower to upper case

You are defining the value of upper using the current value of upper if I'm understanding correctly, that's undefined.

By looking at the code it seems like you should be trying to modify the value of *tmp (turn it to uppercase) before the call to copy_from_user.

Last but not least, you are not taking into account the count, you are assuming that the user only wants to copy 1 character at the end of the block here, I'm not sure if that's what you want to do or not.

Briefly:

• You are not changing the value the user writes, that's why it is not doing anything
• You are only copying 1 character at the end of the block provided by the user
• The code you are using to attempt to change the character to uppercase is wrong

To solve the uppercase part, and considering that you are intending to copy only 1 char and not the entire block, you could try something like this:

/* Memory Write */
ssize_t memory_write( struct file *filp, char *buf,
                      size_t count, loff_t *f_pos)
{
  char *tmp;


  tmp=buf+count-1;
  copy_from_user(memory_buffer,tmp,1);//write to memory

  char to_upper=memory_buffer[0]; //grab the char
  if (to_upper >= 97 && to_upper <= 122) // if the char in is the range a-z
  {
     to_upper = to_upper - 32;// convert to uppercase
     memory_buffer[0] = to_upper;
  }
  printk(KERN_ALERT "memory_write\n");

  return 1;
}

Hope it helps!

Answer 2

In memory_write...

copy_from_user(memory_buffer,tmp,1);
*memory_buffer = 'A' + (*memory_buffer - 'a');