精华内容
下载资源
问答
  • LINUX文件锁定

    2015-09-21 17:08:57
    linux文件锁定有两种:一种是以原子操作方式创建锁文件;另一种是允许锁定文件的一部分,从而独享对这一部分内容的访问。  1、锁文件  许多应用程序只需要能够针对某个资源创建一个锁文件,然后其他程序...

    http://blog.csdn.net/querdaizhi/article/details/7478169 


    linux下文件锁定有两种:一种是以原子操作方式创建锁文件;另一种是允许锁定文件的一部分,从而独享对这一部分内容的访问。

        1、锁文件

        许多应用程序只需要能够针对某个资源创建一个锁文件,然后其他程序通过检查这个文件来判断它们是否被允许访问这个资源。创建锁文件使用fcntl.h头文件定义的open系统调用,并带上O_CREAT和O_EXCL标志。这样就以原子操作完成两项工作:确定文件不存在,然后创建    

    1. #include <unistd.h>  
    2. #include <stdlib.h>  
    3. #include <stdio.h>  
    4. #include <fcntl.h>  
    5. #include <errno.h>  
    6.   
    7. int main()  
    8. {  
    9.     int file_desc;  
    10.     int save_errno;  
    11.   
    12.     file_desc = open("/tmp/LCK.test", O_RDWR | O_CREAT | O_EXCL, 0444);  
    13.     if (file_desc == -1) {  
    14.         save_errno = errno;  
    15.         printf("Open failed with error %d\n", save_errno);  
    16.     }  
    17.     else {  
    18.         printf("Open succeeded\n");  
    19.     }  
    20.     exit(EXIT_SUCCESS);  
    21. }  
         不过在第二次运行以上程序的时候,会提示错误:open failed with error 17(文件已存在,错误码在/usr/include/asm-generic/error-base.h),如果想让程序再次执行成功,就必须删除那个锁文件。在c语言调用中,我们可以使用unlink函数(定义于/usr/include/unistd.h)。另外,以上的代码也不是很合理的,只有open没有close,正常情况下,应该加上以下两行:

    1. (void)close(file_desc);  
    2. (void)unlink( "/tmp/LCK.test");  
         关于unlink,可以参考http://bbs.chinaunix.net/thread-1920145-1-1.html 的说法。unlink原型如下:

    [html] view plaincopy
    1. #include <unistd.h>  
    2. int unlink (__const char *__name)  
        函数功能:删除目录项,并将由__name所引用文件的链接计数减1,当链接计数为0时,文件被删除。
        关于unlink的使用,可以参考《unix环境高级编程》第17章,17.3.2唯一链接,在listen前,先unlink以防文件已经存在,accept后再unlink,防止下次调用处问题。曾经楼主在ACE的unix域套接字ACE_LSOCK上遇到address in use,其实就是锁文件已存在没有删除的问题。

        

         2、区域锁定

        区域锁定出现,是因为锁文件方式并不适用于访问大型的共享文件。如果一个大文件,由一个程序写入数据,但却由不同的程序同时对这个文件进行更新。处理程序不能等待记录程序结束,所以需要一些协调方法来提供对同一个文件的并发访问。linux提供了2种方法来实现:一是fcntl系统调用和lockf调用。

    fcntl系统调用,它的定义如下:

    1. #include<fcntl.h>  
    2. int fcntl(int fildes , int command , ...);  
    fcntl对一个打开的文件描述符进行操作,并能根据commands参数设置完成不同的任务。它为我们提供了三个用于文件锁定的命令选项。

    F_GETLK

    F_SETLK

    F_SETLKW
    当使用这个命令选项时,fcntl的第三个参数必须是一个指向flock结构的指针,所以实际的函数原型为:

    int fcntl(int fildes , int command , struct flock *flock_structure);

    flock(文件锁)结构依赖具体的实现,但它至少包含下述成员:

    short l_type;

    short l_whence;

    off_t l_start;

    off_t l_len;

    pid_t l_pid;


    l_type成员的取值定义在头文件fcntl.h中,

    F_RDLCK 共享(或读)锁

    F_UNLCK 解锁,用来清除锁

    F_WRLCK 独占(或写)锁

    更具体的详情请查看LINUX程序设计P226

        一个使用fcntl锁定文件的例子如下:

    1. #include <unistd.h>  
    2. #include <stdlib.h>  
    3. #include <stdio.h>  
    4. #include <fcntl.h>  
    5.   
    6. const char *test_file = "/tmp/test_lock";  
    7.   
    8. int main() {  
    9.     int file_desc;  
    10.     int byte_count;  
    11.     char *byte_to_write = "A";  
    12.     struct flock region_1;  
    13.     struct flock region_2;  
    14.     int res;  
    15.   
    16.         /* open a file descriptor */  
    17.     file_desc = open(test_file, O_RDWR | O_CREAT, 0666);  
    18.     if (!file_desc) {  
    19.         fprintf(stderr, "Unable to open %s for read/write\n", test_file);  
    20.         exit(EXIT_FAILURE);  
    21.     }  
    22.   
    23.         /* put some data in the file */  
    24.     for(byte_count = 0; byte_count < 100; byte_count++) {  
    25.         (void)write(file_desc, byte_to_write, 1);  
    26.     }  
    27.   
    28.         /* setup region 1, a shared lock, from bytes 10 -> 30 */  
    29.     region_1.l_type = F_RDLCK;  
    30.     region_1.l_whence = SEEK_SET;  
    31.     region_1.l_start = 10;  
    32.     region_1.l_len = 20;   
    33.       
    34.         /* setup region 2, an exclusive lock, from bytes 40 -> 50 */  
    35.     region_2.l_type = F_WRLCK;  
    36.     region_2.l_whence = SEEK_SET;  
    37.     region_2.l_start = 40;  
    38.     region_2.l_len = 10;  
    39.   
    40.         /* now lock the file */  
    41.     printf("Process %d locking file\n", getpid());  
    42.     res = fcntl(file_desc, F_SETLK, ®ion_1);  
    43.     if (res == -1) fprintf(stderr, "Failed to lock region 1\n");  
    44.     res = fcntl(file_desc, F_SETLK, ®ion_2);  
    45.     if (res == -1) fprintf(stderr, "Failed to lock region 2\n");      
    46.   
    47.         /* and wait for a while */  
    48.     sleep(60);  
    49.   
    50.     printf("Process %d closing file\n", getpid());      
    51.     close(file_desc);  
    52.     exit(EXIT_SUCCESS);  
    53. }  
          程序首先创建一个文件,然后以读写方式打开,添加一些数据。接着在文件中设置2个区域,第一个是0-30,用读(共享)锁;第二个是40-50,用写(独占) 锁,然后调用fcntl来锁定这2个区域。
           fcntl参数提供了3个命令选项

           F_GETLK、F_SETLK、F_SETLKW,l_type提供的选项有F_RDLCK、F_UNLCK、F_WRLCK,分别为读锁,解锁,写锁

           测试锁的程序如下:

    1. #include <unistd.h>  
    2. #include <stdlib.h>  
    3. #include <stdio.h>  
    4. #include <fcntl.h>  
    5.   
    6.   
    7. const char *test_file = "/tmp/test_lock";  
    8. #define SIZE_TO_TRY 5  
    9.   
    10. void show_lock_info(struct flock *to_show);  
    11.   
    12.   
    13. int main() {  
    14.     int file_desc;  
    15.     int res;  
    16.     struct flock region_to_test;  
    17.     int start_byte;  
    18.       
    19.         /* open a file descriptor */  
    20.     file_desc = open(test_file, O_RDWR | O_CREAT, 0666);  
    21.     if (!file_desc) {  
    22.         fprintf(stderr, "Unable to open %s for read/write", test_file);  
    23.         exit(EXIT_FAILURE);  
    24.     }  
    25.   
    26.     for (start_byte = 0; start_byte < 99; start_byte += SIZE_TO_TRY) {  
    27.             /* set up the region we wish to test */  
    28.         region_to_test.l_type = F_WRLCK;  
    29.         region_to_test.l_whence = SEEK_SET;  
    30.         region_to_test.l_start = start_byte;  
    31.         region_to_test.l_len = SIZE_TO_TRY;  
    32.         region_to_test.l_pid = -1;       
    33.   
    34.         printf("Testing F_WRLCK on region from %d to %d\n",   
    35.                start_byte, start_byte + SIZE_TO_TRY);  
    36.           
    37.             /* now test the lock on the file */  
    38.         res = fcntl(file_desc, F_GETLK, ®ion_to_test);  
    39.         if (res == -1) {  
    40.             fprintf(stderr, "F_GETLK failed\n");  
    41.             exit(EXIT_FAILURE);  
    42.         }  
    43.         if (region_to_test.l_pid != -1) {  
    44.             printf("Lock would fail. F_GETLK returned:\n");  
    45.             show_lock_info(®ion_to_test);  
    46.         }  
    47.         else {  
    48.             printf("F_WRLCK - Lock would succeed\n");  
    49.         }  
    50.   
    51.             /* now repeat the test with a shared (read) lock */  
    52.           
    53.             /* set up the region we wish to test */  
    54.         region_to_test.l_type = F_RDLCK;  
    55.         region_to_test.l_whence = SEEK_SET;  
    56.         region_to_test.l_start = start_byte;  
    57.         region_to_test.l_len = SIZE_TO_TRY;  
    58.         region_to_test.l_pid = -1;       
    59.   
    60.         printf("Testing F_RDLCK on region from %d to %d\n",   
    61.                start_byte, start_byte + SIZE_TO_TRY);  
    62.           
    63.             /* now test the lock on the file */  
    64.         res = fcntl(file_desc, F_GETLK, ®ion_to_test);  
    65.         if (res == -1) {  
    66.             fprintf(stderr, "F_GETLK failed\n");  
    67.             exit(EXIT_FAILURE);  
    68.         }  
    69.         if (region_to_test.l_pid != -1) {  
    70.             printf("Lock would fail. F_GETLK returned:\n");  
    71.             show_lock_info(®ion_to_test);              
    72.         }  
    73.         else {  
    74.             printf("F_RDLCK - Lock would succeed\n");  
    75.         }  
    76.   
    77.     } /* for */  
    78.       
    79.     close(file_desc);  
    80.     exit(EXIT_SUCCESS);  
    81. }  
    82.   
    83. void show_lock_info(struct flock *to_show) {  
    84.     printf("\tl_type %d, ", to_show->l_type);  
    85.     printf("l_whence %d, ", to_show->l_whence);  
    86.     printf("l_start %d, ", (int)to_show->l_start);          
    87.     printf("l_len %d, ", (int)to_show->l_len);  
    88.     printf("l_pid %d\n", to_show->l_pid);  
    89. }  


    文件锁的竞争

    1. #include <unistd.h>  
    2. #include <stdlib.h>  
    3. #include <stdio.h>  
    4. #include <fcntl.h>  
    5.   
    6.   
    7. const char *test_file = "/tmp/test_lock";  
    8.   
    9. int main() {  
    10.     int file_desc;  
    11.     struct flock region_to_lock;  
    12.     int res;  
    13.   
    14.         /* open a file descriptor */  
    15.     file_desc = open(test_file, O_RDWR | O_CREAT, 0666);  
    16.     if (!file_desc) {  
    17.         fprintf(stderr, "Unable to open %s for read/write\n", test_file);  
    18.         exit(EXIT_FAILURE);  
    19.     }  
    20.   
    21.     region_to_lock.l_type = F_RDLCK;  
    22.     region_to_lock.l_whence = SEEK_SET;  
    23.     region_to_lock.l_start = 10;  
    24.     region_to_lock.l_len = 5;  
    25.     printf("Process %d, trying F_RDLCK, region %d to %d\n", getpid(),  
    26.            (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));  
    27.     res = fcntl(file_desc, F_SETLK, ®ion_to_lock);  
    28.     if (res == -1) {  
    29.         printf("Process %d - failed to lock region\n", getpid());  
    30.     } else {  
    31.         printf("Process %d - obtained lock region\n", getpid());  
    32.     }  
    33.      
    34.     region_to_lock.l_type = F_UNLCK;  
    35.     region_to_lock.l_whence = SEEK_SET;  
    36.     region_to_lock.l_start = 10;  
    37.     region_to_lock.l_len = 5;  
    38.     printf("Process %d, trying F_UNLCK, region %d to %d\n", getpid(),  
    39.            (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));  
    40.     res = fcntl(file_desc, F_SETLK, ®ion_to_lock);  
    41.     if (res == -1) {  
    42.         printf("Process %d - failed to unlock region\n", getpid());  
    43.     } else {  
    44.         printf("Process %d - unlocked region\n", getpid());  
    45.     }  
    46.   
    47.     region_to_lock.l_type = F_UNLCK;  
    48.     region_to_lock.l_whence = SEEK_SET;  
    49.     region_to_lock.l_start = 0;  
    50.     region_to_lock.l_len = 50;  
    51.     printf("Process %d, trying F_UNLCK, region %d to %d\n", getpid(),  
    52.            (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));  
    53.     res = fcntl(file_desc, F_SETLK, ®ion_to_lock);  
    54.     if (res == -1) {  
    55.         printf("Process %d - failed to unlock region\n", getpid());  
    56.     } else {  
    57.         printf("Process %d - unlocked region\n", getpid());  
    58.     }  
    59.       
    60.     region_to_lock.l_type = F_WRLCK;  
    61.     region_to_lock.l_whence = SEEK_SET;  
    62.     region_to_lock.l_start = 16;  
    63.     region_to_lock.l_len = 5;  
    64.     printf("Process %d, trying F_WRLCK, region %d to %d\n", getpid(),  
    65.            (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));  
    66.     res = fcntl(file_desc, F_SETLK, ®ion_to_lock);  
    67.     if (res == -1) {  
    68.         printf("Process %d - failed to lock region\n", getpid());  
    69.     } else {  
    70.         printf("Process %d - obtained lock on region\n", getpid());  
    71.     }  
    72.   
    73.     region_to_lock.l_type = F_RDLCK;  
    74.     region_to_lock.l_whence = SEEK_SET;  
    75.     region_to_lock.l_start = 40;  
    76.     region_to_lock.l_len = 10;  
    77.     printf("Process %d, trying F_RDLCK, region %d to %d\n", getpid(),  
    78.            (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));  
    79.     res = fcntl(file_desc, F_SETLK, ®ion_to_lock);  
    80.     if (res == -1) {  
    81.         printf("Process %d - failed to lock region\n", getpid());  
    82.     } else {  
    83.         printf("Process %d - obtained lock on region\n", getpid());  
    84.     }  
    85.       
    86.     region_to_lock.l_type = F_WRLCK;  
    87.     region_to_lock.l_whence = SEEK_SET;  
    88.     region_to_lock.l_start = 16;  
    89.     region_to_lock.l_len = 5;  
    90.     printf("Process %d, trying F_WRLCK with wait, region %d to %d\n", getpid(),  
    91.            (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));  
    92.     res = fcntl(file_desc, F_SETLKW, ®ion_to_lock);  
    93.     if (res == -1) {  
    94.         printf("Process %d - failed to lock region\n", getpid());  
    95.     } else {  
    96.         printf("Process %d - obtained lock on region\n", getpid());  
    97.     }  
    98.   
    99.     printf("Process %d ending\n", getpid());      
    100.     close(file_desc);  
    101.     exit(EXIT_SUCCESS);  
    102. }  


    其他锁的命令
    #include<unistd.h>
    int lockf(int fildes, int function, off_t size_to_lock);
    funciton参数的取值如下所示:
    F_ULOCK:解锁
    F_LOCK:设置独占锁
    F_TLOCK:测试并设置独占锁
    F_TEST:测试其他进程设置的锁
    size_to_lock参数是操作的字节数,它从文件的当前偏移值开始计算。
    展开全文
  • linux文件锁定

    千次阅读 2011-11-30 12:53:44
    linux文件锁定有两种:一种是以原子操作方式创建锁文件;另一种是允许锁定文件的一部分,从而独享对这一部分内容的访问。  1、锁文件  许多应用程序只需要能够针对某个资源创建一个锁文件,然后其他程序通过...

        linux下文件锁定有两种:一种是以原子操作方式创建锁文件;另一种是允许锁定文件的一部分,从而独享对这一部分内容的访问。

        1、锁文件

        许多应用程序只需要能够针对某个资源创建一个锁文件,然后其他程序通过检查这个文件来判断它们是否被允许访问这个资源。创建锁文件使用fcntl.h头文件(楼主机器上位于/usr/include下)定义的open系统调用,并带上O_CREAT和O_EXCL标志。这样就以原子操作完成两项工作:确定文件不存在,然后    创建    

    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <fcntl.h>
    #include <errno.h>
    
    int main()
    {
        int file_desc;
        int save_errno;
    
        file_desc = open("/tmp/LCK.test", O_RDWR | O_CREAT | O_EXCL, 0444);
        if (file_desc == -1) {
            save_errno = errno;
            printf("Open failed with error %d\n", save_errno);
        }
        else {
            printf("Open succeeded\n");
        }
        exit(EXIT_SUCCESS);
    }
    
         不过在第二次运行以上程序的时候,会提示错误:open failed with error 17(文件已存在,错误码在/usr/include/asm-generic/error-base.h),如果想让程序再次执行成功,就必须删除那个锁文件。在c语言调用中,我们可以使用unlink函数(定义于/usr/include/unistd.h)。另外,以上的代码也不是很合理的,只有open没有close,正常情况下,应该加上以下两行:

                (void)close(file_desc);
                (void)unlink( "/tmp/LCK.test");
         关于unlink,可以参考http://bbs.chinaunix.net/thread-1920145-1-1.html 的说法。unlink原型如下:

    #include <unistd.h>
    int unlink (__const char *__name)
        函数功能:删除目录项,并将由__name所引用文件的链接计数减1,当链接计数为0时,文件被删除。
        关于unlink的使用,可以参考《unix环境高级编程》第17章,17.3.2唯一链接,在listen前,先unlink以防文件已经存在,accept后再unlink,防止下次调用处问题。曾经楼主在ACE的unix域套接字ACE_LSOCK上遇到address in use,其实就是锁文件已存在没有删除的问题。

        

         2、区域锁定

        区域锁定出现,是因为锁文件方式并不适用于访问大型的共享文件。如果一个大文件,由一个程序写入数据,但却由不同的程序同时对这个文件进行更新。处理程序不能等待记录程序结束,所以需要一些协调方法来提供对同一个文件的并发访问。linux提供了2种方法来实现:一是fcntl系统调用和lockf调用。

        一个使用fcntl锁定文件的例子如下:

    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <fcntl.h>
    
    const char *test_file = "/tmp/test_lock";
    
    int main() {
        int file_desc;
        int byte_count;
        char *byte_to_write = "A";
        struct flock region_1;
        struct flock region_2;
        int res;
    
            /* open a file descriptor */
        file_desc = open(test_file, O_RDWR | O_CREAT, 0666);
        if (!file_desc) {
            fprintf(stderr, "Unable to open %s for read/write\n", test_file);
            exit(EXIT_FAILURE);
        }
    
            /* put some data in the file */
        for(byte_count = 0; byte_count < 100; byte_count++) {
            (void)write(file_desc, byte_to_write, 1);
        }
    
            /* setup region 1, a shared lock, from bytes 10 -> 30 */
        region_1.l_type = F_RDLCK;
        region_1.l_whence = SEEK_SET;
        region_1.l_start = 10;
        region_1.l_len = 20; 
        
            /* setup region 2, an exclusive lock, from bytes 40 -> 50 */
        region_2.l_type = F_WRLCK;
        region_2.l_whence = SEEK_SET;
        region_2.l_start = 40;
        region_2.l_len = 10;
    
            /* now lock the file */
        printf("Process %d locking file\n", getpid());
        res = fcntl(file_desc, F_SETLK, ®ion_1);
        if (res == -1) fprintf(stderr, "Failed to lock region 1\n");
        res = fcntl(file_desc, F_SETLK, ®ion_2);
        if (res == -1) fprintf(stderr, "Failed to lock region 2\n");    
    
            /* and wait for a while */
        sleep(60);
    
        printf("Process %d closing file\n", getpid());    
        close(file_desc);
        exit(EXIT_SUCCESS);
    }
    
          程序首先创建一个文件,然后以读写方式打开,添加一些数据。接着在文件中设置2个区域,第一个是0-30,用读(共享)锁;第二个是40-50,用写(独占) 锁,然后调用fcntl来锁定这2个区域。
           fcntl参数提供了3个命令选项

           F_GETLK、F_SETLK、F_SETLKW,l_type提供的选项有F_RDLCK、F_UNLCK、F_WRLCK,分别为读锁,解锁,写锁

           测试锁的程序如下:

    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <fcntl.h>
    
    
    const char *test_file = "/tmp/test_lock";
    #define SIZE_TO_TRY 5
    
    void show_lock_info(struct flock *to_show);
    
    
    int main() {
        int file_desc;
        int res;
        struct flock region_to_test;
        int start_byte;
        
            /* open a file descriptor */
        file_desc = open(test_file, O_RDWR | O_CREAT, 0666);
        if (!file_desc) {
            fprintf(stderr, "Unable to open %s for read/write", test_file);
            exit(EXIT_FAILURE);
        }
    
        for (start_byte = 0; start_byte < 99; start_byte += SIZE_TO_TRY) {
                /* set up the region we wish to test */
            region_to_test.l_type = F_WRLCK;
            region_to_test.l_whence = SEEK_SET;
            region_to_test.l_start = start_byte;
            region_to_test.l_len = SIZE_TO_TRY;
            region_to_test.l_pid = -1;     
    
            printf("Testing F_WRLCK on region from %d to %d\n", 
                   start_byte, start_byte + SIZE_TO_TRY);
            
                /* now test the lock on the file */
            res = fcntl(file_desc, F_GETLK, ®ion_to_test);
            if (res == -1) {
                fprintf(stderr, "F_GETLK failed\n");
                exit(EXIT_FAILURE);
            }
            if (region_to_test.l_pid != -1) {
                printf("Lock would fail. F_GETLK returned:\n");
                show_lock_info(®ion_to_test);
            }
            else {
                printf("F_WRLCK - Lock would succeed\n");
            }
    
                /* now repeat the test with a shared (read) lock */
            
                /* set up the region we wish to test */
            region_to_test.l_type = F_RDLCK;
            region_to_test.l_whence = SEEK_SET;
            region_to_test.l_start = start_byte;
            region_to_test.l_len = SIZE_TO_TRY;
            region_to_test.l_pid = -1;     
    
            printf("Testing F_RDLCK on region from %d to %d\n", 
                   start_byte, start_byte + SIZE_TO_TRY);
            
                /* now test the lock on the file */
            res = fcntl(file_desc, F_GETLK, ®ion_to_test);
            if (res == -1) {
                fprintf(stderr, "F_GETLK failed\n");
                exit(EXIT_FAILURE);
            }
            if (region_to_test.l_pid != -1) {
                printf("Lock would fail. F_GETLK returned:\n");
                show_lock_info(®ion_to_test);            
            }
            else {
                printf("F_RDLCK - Lock would succeed\n");
            }
    
        } /* for */
        
        close(file_desc);
        exit(EXIT_SUCCESS);
    }
    
    void show_lock_info(struct flock *to_show) {
        printf("\tl_type %d, ", to_show->l_type);
        printf("l_whence %d, ", to_show->l_whence);
        printf("l_start %d, ", (int)to_show->l_start);        
        printf("l_len %d, ", (int)to_show->l_len);
        printf("l_pid %d\n", to_show->l_pid);
    }
    
    (以上大部分内容来自《linux程序设计》)

         就是这样吧,遇到的东西是越来越多,慢慢总结

    展开全文
  • linux 文件锁定

    千次阅读 2010-07-19 16:23:00
    文件锁定   文件锁定是多任务操作系统中一个非常重要的组成部分。程序通常需要共享数据,而通常是通过文件来实现的。   创建锁文件   许多应用程序只要能够针对某个资源创建...

    文件锁定

     

    文件锁定是多任务操作系统中一个非常重要的组成部分。程序通常需要共享数据,而通常是通过文件来实现的。

     

    创建锁文件

     

    许多应用程序只要能够针对某个资源创建一个锁文件即可。然后,其他程序就可以通过检查这个文件的状态来判断它们自己

     

    是否被允许访问这个资源。(锁文件仅仅只是充当一个指示器的角色,程序需要通过相互协作来使用它们)

     

    实例:

    #include <unistd.h>

    #include <stdlib.h>

    #include <stdio.h>

    #include <fcntl.h>

    #include <errno.h>

     

    int main()

    {

         int file_desc;

         int save_errno;

     

         file_desc=open("/tmp/LCK.test",ORDWR | O_CREAT | O_EXCL,0444);

         if(file_desc == -1)

         {

                save_errno = errno;

                printf("open failed with error %d/n",save_errno);

         }

         else

              printf("open succeed/n");

     

         exit (EXIT_SUCCESS);

    }

     

    第一次运行程序

    open  succeeded


    再次运行

    open failed with error 17

     

    锁定区域

     

    用创建件锁文件的办法来控制诸如串口之类的资源的独占实访问是一个不错的选择,但他并不适合用于访问大型的共享文件。

     

    比如,你有一个大文件,由一个程序写入数据,但同时又有许多不同的程序同时对这个文件进行更新。这个时候,我们可以通过

     

    锁定区域来解决这个问题,文件部分被锁定,但其他程序可以访问这个文件的其他部分。linux提供至少两种方式来完成这一工作

     

    使用fcntl系统调用和lockf调用。现在我们来介绍fcntl接口:

     

    fcntl接口 定义:

     

    #include <fcntl.h>

    int fcntl (int fildes,int command,struct flock *flock_structure);

     

    fcntl对一个打开的文件描述符进行操作,并能根据command参数的设置完成不同的任务。他为我们提供来三个用于文件锁的命令:

     

    F_GETLK                 //获取文件锁的信息

     

    F_SETLK                  //设置文件锁定的状态

     

    F_SETLKW             //设置文件锁定的状态,但是无法建立锁定是,此调用会一直等到锁定动作成功为止

     

    flock结构 定义如下:

     

    struct flock{

     

    short int l_type;                   //锁定的状态

    short int l_whence;            //决定l_stat的位置

    off_t    l_start;                      //锁定区域的开始位置

    off_t    l_len;                        //锁定区域的大小

    pid_t    l_pid;                       //锁定动作的进程

     

    }

     

     

    展开全文
  • Linux - 锁定文件

    2019-09-23 09:00:45
    锁定关键的系统文件可以防止服务器提权后篡改 对启动文件和账号密码文件进行加锁 [root@sch01ar ~]# chattr +i /etc/passwd /etc/shadow /etc/group /etc/gshadow /etc/inittab 这些文件上锁后,任何用户...

    锁定关键的系统文件可以防止服务器提权后被篡改

    对启动文件和账号密码文件进行加锁

    [root@sch01ar ~]# chattr +i /etc/passwd /etc/shadow /etc/group /etc/gshadow /etc/inittab
    

    这些文件上锁后,任何用户都不能对这些文件进行修改和删除

    root 用户强制保存退出也不行

    如果想对这些文件进行操作的话,可以先对这些文件解锁,修改后再加锁

    对这些文件解锁

    [root@sch01ar ~]# chattr -i /etc/passwd /etc/shadow /etc/group /etc/gshadow /etc/inittab
    

    可以把 chattr 改名,防止被黑客利用

    [root@sch01ar ~]# mv /usr/bin/chattr /usr/bin/test
    

     

    转载于:https://www.cnblogs.com/sch01ar/p/9456340.html

    展开全文
  • --用户被锁定 多次认证失败 解决办法 pam_tally2 -u username --reset   --修改文件修改时间 touch -t 201801010728 fileName   --查看文件修改时间 stat IOT_IOT_DDR* | grep -i Modify | awk -F. '{print...
  • 锁定重要文件如下: chattr +i /etc/passwd /etc/shadow /etc/groupp /etc/gshadow 解锁文件 chattr -i /etc/passwd /etc/shadow /etc/groupp /etc/...查看文件是否被锁定 lsattr /etc/passwd 就可以看到 ...
  • linux安全加固-锁定关键系统文件,防止提权篡改 要锁定关键系统文件,必须对账号密码文件及启动文件加锁,防止篡改。 chattr与lsattr chattr命令可以锁定文件。 通过chattr命令修改属性能够提高系统的安全性,...
  • 锁定文件会阻止 Linux 系统中某些文件或者数据的访问,这个概念也存在于 Windows 或者其他的操作系统中。 一旦你运行了 apt-get 或者 apt 命令,锁定文件将会创建于 /var/lib/apt/lists/、/var/lib/dpkg/、/var/...
  • linux文件系统安全

    2016-03-16 19:54:12
     系统运维人员有时候可能会遇到通过root用户都不能修改或者删除某个文件的情况,产生这种情况的大部分原因可能是这个文件被锁定了。在Linux下锁定文件的命令是chattr,通过这个命令可以修改ext2、ext3、ext4文件...
  • IO Lock 版权声明:本文为 cdeveloper 原创文章,可以随意转载,但必须...但是对于一些特殊的程序,如数据库有时需要独占一个文件,这时就不能让这个文件被多个进程同时操作了。于是 UNIX 系统提供了文件锁来实现...
  • 为了使我们的linux系统更安全,减少黑客入侵的可能性,可以使用chattr命令对系统中的关键文件进行锁定。如: #chattr +i /etc/passwd /etc/shadow /etc/groupp /etc/gshadow  将系统中的passwd,shadow,group....
  • Linux 虚拟机报错:另一个程序已锁定文件的一部分,进程无法访问。。0x00 问题0x01 原因0x02 解决 0x00 问题 •另一个程序已锁定文件的一部分,进程无法访问(或者:锁定文件失败 ) •打不开磁盘“。。。”或它所...
  • 但是对于一些特殊的程序,如数据库有时需要独占一个文件,这时就不能让这个文件被多个进程同时操作了。于是 UNIX 系统提供了文件锁来实现这种独占文件的功能。 文件锁:当一个进程正在读或者或者修改文件的某个部分...
  • linux 文件

    2016-10-20 20:42:18
    用户在更新文件时,期望可以使用某种机制,防止两种进程同时更新文件同一区域而造成丢失,或者防止文件内容在未更新完毕时读取等并发引起的问题,这种机制就是文件锁。  进程在操作文件期间,可以使用文件锁,...
  • 防止Linux系统中重要文件被修改,请使用chattr命令 以下为我常用锁定关键文件 添加文件锁定 chattr +i /etc/fstab chattr +i /etc/passwd chattr +i /etc/shadow chattr +i /etc/group chattr +i /etc/groupshadow ...
  • Linux文件---文件锁

    千次阅读 2017-09-02 17:03:12
    对于文件的操作而言,“锁定”操作是对文件(尤其是对共享文件)的一种高级的文件操作。当某进程在更新文件内数据时,期望某种机制能防止多个进程同时更新文件从而导致数据丢失,或者防止文件内容在未更新完毕时...
  • linux 文件和记录锁

    2015-03-23 17:39:12
    文件锁定的是整个文件,而记录锁定锁定文件的某一特定部分。UNIX 的记录指的 是从文件的某一相对位置开始的一段连续的... 咨询式锁定后,其它想要访问该文件的进程将操作系统告知共享文件已经上了锁,但这并不阻止它
  • Linux 文件锁 & pid

    千次阅读 2012-09-19 17:56:07
    Linux 提供了多种特性来实现文件锁定。 一. 创建锁文件  许多应用程序只需要能够针对某个资源创建一个锁文件即可,然后,其它程序就可以通过检查这个文件来判断它们自己是否能够允许访问这个资源。这些锁文件...
  • 原因:本人因在设置虚拟机时CD/DVD硬件连接方式将使用iso映像文件改成了物理驱动连接,导致VMware Linux虚拟机启动时提示“锁定文件失败...” 、 (注:期间碰到进程占用问题,解决:Ctrl+Alt+Del打开任务管理...
  • 用户在更新文件时,期望可以使用某种机制,防止两种进程同时更新文件同一区域而造成丢失,或者防止文件内容在未更新完毕时读取等并发引起的问题,这种机制就是文件锁。  进程在操作文件期间,可以使用文件锁,...
  • linux清空文件内容

    2018-08-19 20:36:00
     当tomcat运行时,tomcat的日志文件tomcat进程锁定,强制删除是会失败的。如果想要立即清空文件内容,可以使用如下几种方式。 (1)使用空流覆盖文件,完成一次写入操作 #最简单的方式 > access_log....
  • linux 中的文件

    2016-07-05 21:33:37
    因此,当一个进程多次调用read读文件时,就有可能在某两次读之间另一进程所写,因此,读的的值将发生错误,造成了文件数据的随机性冲突,为解决此类并发进程对共享文件的访问控制问题,Linux设计了锁机制。...
  • 有时候你发现用root权限都不能修改某个文件,大部分原因是曾经用chattr命令锁定文件了。chattr命令的作用很大,其中一些功能是由Linux内核版本来支持。通过chattr命令修改属性能够提高系统的安全性,但是它并不...
  • 但是android是基于linux操作系统的,linux比较底层,灵活性也更大,为了实现锁定文件的效果,大概有以下几种办法: 用chmod命令修改文件读写权限 利用linux中的多线程独占锁,启动一个长期占用文件的后台线程 使用...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 288
精华内容 115
关键字:

linux文件被锁定

linux 订阅