Detailed explanation of the commonly used functions copy_from_user open read write in Linux driver development

Common functions of linux drivers (copy_from_user open read write)

1.open

Function definition:
int open( const char * pathname, int flags);
int open( const char * pathname,int flags, mode_t mode);
Parameter Description:
pathname: The name of the file, which can contain (absolute and relative) paths
flags: file opening mode
mode: used to define the access rights of the file owner, the file's user group, and other users in the system. The file permissions are: mode&(~umask)
Function Description:
The pathname parameter points to the file path string to be opened. The following are the flags that can be used with the flags parameter:

• O_RDONLY opens the file in read-only mode;
• O_WRONLY opens the file for writing only;
• O_RDWR opens the file in readable and writable mode;

The above three flags are mutually exclusive, that is, they cannot be used at the same time, but can be combined with the following flags using the OR (|) operator;

• O_CREAT If the file to be opened does not exist, the file will be created automatically;
• O_EXCL If O_CREAT is also set, this command will check if the file exists. If the file does not exist, it will be created. Otherwise, an error will occur in opening the file. In addition, if O_CREAT and O_EXCL are set at the same time and the file to be opened is a symbolic link, the file opening will fail.
• O_NOCTTY If the file to be opened is a terminal device, the terminal will not be used as the process control terminal;
• O_TRUNC If the file exists and is opened in writable mode, this flag will clear the file length to 0, and the data originally stored in the file will disappear;
• O_APPEND When reading or writing a file, the data will be added to the end of the file.
• O_NONBLOCK opens the file in an unblockable way, that is, it returns to the process immediately regardless of whether there is data to read or wait;
• O_NDELAY is the same as O_NONBLOCK;
• O_SYNC opens the file synchronously;
• O_NOFOLLOW If the file pointed to by the parameter pathname is a symbolic link, the file opening will fail;
• O_DIRECTORY If the file pointed to by the parameter pathname is not a directory, the file opening will fail.

This is a flag specific to Linux 2.2 and later to avoid some system security issues. The parameter mode has the following combinations, which will only take effect when creating a new file. In addition, the permissions when actually creating a file will be affected by the umask value, so the file permissions should be (mode-umaks).

• S_IRWXU00700 permission, which means the file owner has read, write, and execute permissions;
• S_IRUSR or S_IREAD, 00400 permissions, which means the file owner has read permissions;
• **S_IWUSR or S_IWRITE, 00200 **permission, indicating that the file owner has write permission;
• S_IXUSR or S_IEXEC, 00100 permissions, which means the file owner has executable permissions;
• S_IRWXG 00070 permissions, which means the file user group has read, write, and execute permissions;
• S_IRGRP 00040 permission, indicating that the file user group has read permission;
• S_IWGRP 00020 permission, indicating that the file user group has write permission;
• S_IXGRP 00010 permission, indicating that the file user group has executable permission;
• S_IRWXO 00007 permission, which means other users have read, write and execute permissions;
• S_IROTH 00004 permission, indicating that other users have readable permission;
• S_IWOTH 00002 permission, indicating that other users have write permission;
• S_IXOTH 00001 permission, indicating that other users have executable permission.

Return value:
If all permissions to be checked pass the check, a value of 0 is returned, indicating success. If any permission is denied, -1 is returned.

Error code:
EEXIST The file referred to by the parameter pathname already exists, but the O_CREAT and O_EXCL flags are used;
EACCESS The file pointed to by the parameter pathname does not meet the permissions required for the test;
EROFS The file to be tested for write permission exists in a read-only file system;
EFAULT The parameter pathname pointer exceeds the accessible memory space;
EINVAL The parameter mode is incorrect;
ENAMETOOLONG Parameter pathname is too long;
ENOTDIR The parameter pathname is not a directory;
ENOMEM Insufficient kernel memory;
ELOOP The parameter pathname has too many symbolic links.
EIO I/O access error.

#include
#include
#include
#include
main()
{
    int fd,size;
    char s[]=”Linux Programmer!\n”,buffer[80];
    fd = open("/tmp/temp", O_WRONLY | O_CREAT);
    write(fd,s,sizeof(s));
    close(fd);
    fd = open ("/tmp/temp", O_RDONLY);
    size=read(fd,buffer,sizeof(buffer));
    close(fd);
    printf("%s",buffer);
}

2.read

Function definition:
ssize_t read(int fd, void * buf, size_t count);

Function description:
read() will transfer count bytes from the file pointed to by the parameter fd to the memory pointed to by the buf pointer.

Return value:
The return value is the number of bytes actually read. If 0 is returned, it means the end of the file has been reached or there is no more data to read. If the count parameter is 0, read() will have no effect and return 0.

Notice:
If the data in fd is smaller than the data to be read during read, it will cause blocking.
The usage of read is simpler than write, so I will not go into details here. Since the author's level is limited, if there are any errors in the article, I would like to ask you to point them out to avoid misleading everyone.

3.write

Function definition:
ssize_t write (int fd, const void * buf, size_t count);

Function description:
write() will write count bytes from the memory pointed to by the parameter buf to the file pointed to by the parameter.

Return value:
If all goes well, write() will return the number of bytes actually written. If an error occurs, -1 is returned and the error code is stored in errno.
(1) The return value of the write() function is usually not 0. It will only return 0 when the following situation occurs: the third parameter in write(fp, p1+len, (strlen(p1)-len) is 0. In this case, write() does nothing and only returns 0. The description of the return value of write() given in the man manual is as follows:
(2) When the write() function writes data from buf to fd, if the data in buf cannot be read all at once, then when the data in buf is read for the second time, its read position pointer (that is, the second parameter buf) will not move automatically. The programmer needs to control it programmatically instead of simply filling the first address of buf into the second parameter. For example, the read position can be moved in the following format: write(fp, p1+len, (strlen(p1)-len). In this way, the second write loop will write data from p1+len to fp, and the same goes for the rest until (strlen(p1)-len becomes 0.

The following example illustrates the usage of the write function:

#include 
#include 
#include 
int main()
{
  char *p1 = "This is ac test code";
  volatile int len ​​= 0;
 
  int fp = open("/home/test.txt", O_RDWR|O_CREAT);
  for(;;)
  {
     int n;
 
     if((n=write(fp, p1+len, (strlen(p1)-len)))== 0) //if((n=write(fp, p1+len, 3)) == 0) 
     { //strlen(p1) = 21
         printf("n = %d \n", n);
         break;
     }
     len+=n;
  }
  return 0;
}

(3) Within the maximum data range that can be written at one time (seemingly BUFSIZ, 8192), the third parameter count should preferably be the size of the data in buf to avoid errors. (After another test, I found that the maximum number of data that can be written at one time is not 8192. I tried to write 81920000 at a time, and the result was also OK. It seems that the maximum number of data that can be written at one time is not 8192. However, there is indeed a parameter called BUFSIZ in the kernel, and its specific meaning remains to be studied.)

4.copy_to_user

Function definition:
unsigned long copy_to_user(void *to, const void *from, unsigned long n)
Parameter Description:
to: target address (user space)
from: source address (kernel space)
n: The number of bytes of data to be copied
Function description:
Read data from kernel space to user space
Return value:
If successful, it returns 0; if failed, it returns the number of bytes of data that were not copied successfully.

5.copy_from_user

Function definition:
unsigned long copy_from_user(void *to, const void *from, unsigned long n);
Parameter Description:
to: target address (kernel space)
from: source address (user space)
n: The number of bytes of data to be copied
Function description:
Read data from user space to kernel space
Return value:
If successful, it returns 0; if failed, it returns the number of bytes of data that were not copied successfully.

The above is the details of the commonly used functions of Linux drivers (copy_from_user open read write). For more information about commonly used functions of Linux drivers, please pay attention to other related articles on 123WORDPRESS.COM! , I hope everyone will support 123WORDPRESS.COM in the future!