Linux File Operation learning Summary "reprint"

This article was reproduced from: http://blog.csdn.net/xiaoweibeibei/article/details/6556951

file Type: Normal file (text file, binary file), catalog file, link file, device file, pipeline file.    

Permissions for files: Read, write, execute

Information about the file: directory structure, index node, file data

of the index node Stat structure

struct stat{

dev_t the device number used by the st_dev;//file

ino_t st_inl;//Index Node number

mode_t st_mode;//File access rights

nlink_t number of hard links to st_nlink;//files

uid_t st_uid;//User identification number

gid_t st_gid;//Group Identification number

dev_t the device number of the st_rdev;//device file

off_t st_size;//file Capacity in bytes

unsigned long st_blksize;//the size of the disk block that contains the file

Unsigned a long st_blocks;//file occupies a disk block

time_t st_atime;//the last time to access the file

time_t st_mtime;//last time the file was modified

time_t st_ctime;//The last time the file state was changed

} ;

In this structure, St_dev corresponds to each file name, representing the device number of the filesystem containing the file name and the corresponding index node, and St_rdev only the character device and the fast device, which represents the device number of the actual device.

File manipulation related functions

File creation

function : int creat (const char *pathname,mode_t mode);

header file:sys/types.h sys/stat.h fcntl.h

Description

The mode takes the following values:

Mode Take value	Meaning
S_irusr	Read permission for the file owner
S_iwusr	Write permission for file security owner
S_ixusr	Execution rights for file owners
S_irgrp	Read permissions for file owners and groups of users
S_iwgrp	Write permissions for file owners with group users
S_ixgrp	Execute permissions for file owners and groups of users
S_iroth	Read permissions for other users
S_iwoth	Write permissions for other users
S_ixoth	Execution rights for other users

Several permissions combinations are also defined in the Linux system:

S_irwxu = (s_irusr| s_iwusr| S_IXUSR)

S_irwxg = (s_iwgrp| s_iwgrp| S_IXGRP)

S_irwxo= (s_iroth| s_iwoth| S_ixoth)

When the call succeeds, returns the descriptor of the file, which returns 1, when the file is opened as read-only.

File Open

function:(1) int open (const char *pathname,int flags);

(2) int open (const char *pathname,int flags,mode_t mode);

header file:sys/types.h sys/stat.h fcntl.h

Description:flags is used to describe file open parameters, which are added by bitwise logic, where o_rdonly,o_wronly and o_rdwr,3 values must contain one of them. The flags are valued as follows:

Flags Take value	Meaning
O_rdonly	Open as read-only
O_wronly	Open in write-only mode
O_rdwr	Open in read and write mode
O_creat	If the file you opened does not exist, create this file
O_excl	If the o_creat bit is set when the file is opened and the file exists, it causes a failure
O_noctty	If the process does not control the TTY while the TTY is open, the terminal is not controlled
O_trunc	If you open an existing file as write-only or read-write, the file will be up to 0
O_append	Opens as an append, placing the pointer at the end of the file when adding content to the file
O_nonblock	For non-blocking interface I/O, if the operation cannot be completed without delay, it is returned before the operation
O_nodelay	With O_nonblack
O_sync	Returns only after data is written to external memory or other devices

When the call succeeds, returns the descriptor of the file to be opened, the call fails back to 1, and the errno is the corresponding error number.

File Close

function:int close (int fd);

header file:unistd.h

Description

Returns 0 on success, 1 on Failure, collocated errno for EBADF. When you open a file that is a reference count in the file description plus 1, when you close a file, the reference count of the file is reduced by 1, and when the reference count is 0 o'clock, the close call not only releases the descriptor of the file, but also releases the description table entry that the file occupies.

File Write operations

function:ssize_t write (int fd,void *buf,size_t count);

header file:unistd.h

Description: The call succeeded in returning the number of bytes written to the segment, failure returns-1, and the corresponding errno is set.

File read operations

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

header file:unistd.h

Description: The call succeeded in returning the number of bytes read, the failure returned-1, and the corresponding errno was set.

File location Operations

Function: off_t lseek (int fildes.off_t offset,int whence);

header file:unistd.h

Description: The call succeeded in returning the actual offset relative to the beginning of the file, and failed to return 1, and set the corresponding errno. The whence values are as follows:

whence Take value	Meaning
Seek_set	Calculates the offset from the beginning of the file;
Seek_cur	Calculates the offset from the current position;
Seek_end	Calculates the offset from the end of the file

File Property Modification

function: (1) int chown (const char *pathname,uid_t owner,gid_t Group);

(2) int fchown (int fd,uid_t owner,gid_t Group);

header files:sys/types.h unistd.h

Description: Change the owner of the file, due to permissions issues, only the root user can call Chown and fchown to arbitrarily change the owner of a file and the group, ordinary users do not have this permission, ordinary users can only modify their own all the files of the group identification number, Can only be selected in the group to which they belong.

function: (1) int chmod (char *pathname,mode_t mode);

(2) int fchmod (int fd,mode_t mode;

header files:sys/types.h unistd.h

Description: Change the access permissions of the file, about the permissions of the settings and the chmod command similar, the call successfully returned 0, failed to return 1, and set errno.

File Rename

function:int rename (const char *oldname,const char *newname);

header file:stdio.h

Description: when NewName and Oldname point to the same, the rename call does nothing to return successfully.

oldname Pointing	newname point to file does not exist	newname point to normal file	newname pointing to the directory file
Oldname point to Normal file	File is renamed	File Rename	Error return
Oldname pointing to the directory file	File Rename	Error	NewName The directory file pointed to is an empty directory, the directory is deleted, Oldname is renamed, or an error is returned

DUP and the dup2 called

function: (1) int dup (int fd); (2) int dup2 (int fd,int fd2);

header file:unistd.h

Note: The call will copy the file descriptor, and the two invocations will return the new file descriptor when executed successfully, the difference being that (2) the file descriptor Fd2 can be predetermined, and if FD2 is being used, close fd2 first, if FD2 and FD are the same, Does not close the file normally returns;

Stat , Fstat and the Lstat called

function: (1) int stat (const char *pathname,struct stat *sbuf);

(2) int fstat (int fd,struct stat *sbuf);

(3) int lstat (const char *pathname,struct stat*buf);

header file:sys/types.h sys/stat.h unistd.h

Note: for Lstat, when accessing a symbolic link, lstat only returns information about the link itself, and stat and Fstat trace to the end of the link file, which is the attached file.

Fsync called

function:int fsync (int fd);

header file:unistd.h

Note: All data stored in the buffer to be written to the file descriptor FD is flushed to the file to be written, and when the call returns 0 successfully, the call fails back to 1, and the errno is set.

Flock called

function:int flock (int fd,int operation);

header file:sys/types.h

Note: to lock or unlock files corresponding to file descriptors, operation is used to indicate different locking or unlocking methods, with the following values:

Lock_sh: Shared lock LOCK_EX: Exclusive lock Lock_un: Unlocking

A process can have only one exclusive lock on a file, but there may be multiple shared locks, which cannot be accessed if a process does not attempt to lock a file that has been locked. Returns 0 when the call succeeds and returns-1 if it fails.

Fcntl called

function: (1) int fcntl (int fd,int cmd);

(2) int fcntl (int fd,int cmd,long arg);

header files:unistd.h fcntl.h

Description: The parameter arg is an optional parameter, corresponding to some of the desirable values of CMD, corresponding to perform some special operations, return 0 on successful invocation, failure to return 1, and set errno, in addition, most of the operations that the FCNTL call can accomplish can be done with other calls. The values of CMD are as follows:

cmd Take value	Appropriate action
F_dupfd	Copy file descriptor
F_getfd	Get file Descriptor
F_setfd	Setting the CLOSE-ON-EXEC flag
F_getfl	Gets the flags for the open call setting
F_setfl	Set the flags for the open call setting
F_getlk	Get a discrete file lock
F_setlk	Set to get a discrete file lock without waiting for
F_setlkw	Set to get a discrete file lock and wait if necessary
F_getown	Retrieves the Sigio and Sigurg semaphore process ID or process group number that will be received
F_setown	Set process ID or process group number

Special File operations

Create a Directory

function:int mkdir (const char *pathname,mde_t mode);

header files:sys/types.h sys/stat.h

Description:The value of mode represents its permission, and the value of mode is determined by the current Umask value and the set mode phase, and the owner of the directory is the valid user identification number of the process that called mkdir to create it. The call returns 0 successfully, the failure returns-1, and the errno is set.

Delete Directory

function:int rmdir (const char *pathname);

header file:unistd.h

Description: When the directory is empty, call this function to delete it, or the deletion will fail. The call returns 0 successfully, the failure returns-1, and the errno is set.

Open Directory

function: DIR * OPENDIR (const char *pathname);

header files: sys/types.h dirent.h

Description: The call return value is the Dir type, which is used to point to the structure pointer to the directory file. The call successfully returned a directory pointer, and the call failed to return null.

Close Directory

function:int closedir (DIR *DP);

header files:sys/types.h dirent.h

Description: The parameter is the directory file pointer to close, the pointer has Opendir returned, the call returns 0 successfully, the failure returns 1, and the errno is set.

Read Directory

function:struct dirent * Readdir (DIP *DP);

header files:sys/types.h dirent.h

Description: The directory file used to access the directory pointer DP, whose return value is the dirent struct pointer, the dirent structure is as follows:

struct drent{

ino_t d_ino;//Directory Node number

off_t d_off;//Node Offset

Unsigned short d_reclen;//record length

unsigned char d_type;//file type

Char d_name[256];//the file name of the directory link

}

When there are no more links in the directory, 0 is returned.

Create a hard link

function:int link (char *pathname1,char *pathname2);

header file:unistd.h

Description:pathname1 for existing files, pathname2 for the link to be established, pathname1 and pathname2 the west of the path must be in the same file system, only Superuser can create a new connection file to the directory file. The call returns 0 successfully, and the failure returns-1.

Remove a hard link

function:int unlink (char *pathname);

header file:unistd.h

Note: to remove a link to a file, you must have write permission and execute permission on the directory, and when unlink is called, the index node count of the directory will be reduced by 1, and when the link calculator is 0 o'clock, the index node and the file data block will be freed.

Creating Symbolic Links

function:int symlink (const char *actualpath,const char *sympath);

header file:unistd.h

Description:Acturalpath is a real-world file, Sympath for the newly created symbolic link to Acturalpath, the call successfully returned 0, failed to return 1, and set errno.

Open link

function:int readlink (const char *pathname, char *buf,int bufsize);

header file:unistd.h

Description: When the call succeeds, the return value is the number of bytes written to the buffer, the return value is 0 when the call fails, and the errno is set.