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

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

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

        1、锁文件

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

    [cpp]  view plain copy
    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,正常情况下,应该加上以下两行:

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

    [html]  view plain copy
    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系统调用,它的定义如下:

    #include<fcntl.h>
    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锁定文件的例子如下:

    [cpp]  view plain copy
    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,分别为读锁,解锁,写锁

           测试锁的程序如下:

    [cpp]  view plain copy
    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. }  


    文件锁的竞争

    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <fcntl.h>
    
    
    const char *test_file = "/tmp/test_lock";
    
    int main() {
        int file_desc;
        struct flock region_to_lock;
        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);
        }
    
        region_to_lock.l_type = F_RDLCK;
        region_to_lock.l_whence = SEEK_SET;
        region_to_lock.l_start = 10;
        region_to_lock.l_len = 5;
        printf("Process %d, trying F_RDLCK, region %d to %d\n", getpid(),
               (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));
        res = fcntl(file_desc, F_SETLK, ®ion_to_lock);
        if (res == -1) {
            printf("Process %d - failed to lock region\n", getpid());
        } else {
            printf("Process %d - obtained lock region\n", getpid());
        }
       
        region_to_lock.l_type = F_UNLCK;
        region_to_lock.l_whence = SEEK_SET;
        region_to_lock.l_start = 10;
        region_to_lock.l_len = 5;
        printf("Process %d, trying F_UNLCK, region %d to %d\n", getpid(),
               (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));
        res = fcntl(file_desc, F_SETLK, ®ion_to_lock);
        if (res == -1) {
            printf("Process %d - failed to unlock region\n", getpid());
        } else {
            printf("Process %d - unlocked region\n", getpid());
        }
    
        region_to_lock.l_type = F_UNLCK;
        region_to_lock.l_whence = SEEK_SET;
        region_to_lock.l_start = 0;
        region_to_lock.l_len = 50;
        printf("Process %d, trying F_UNLCK, region %d to %d\n", getpid(),
               (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));
        res = fcntl(file_desc, F_SETLK, ®ion_to_lock);
        if (res == -1) {
            printf("Process %d - failed to unlock region\n", getpid());
        } else {
            printf("Process %d - unlocked region\n", getpid());
        }
        
        region_to_lock.l_type = F_WRLCK;
        region_to_lock.l_whence = SEEK_SET;
        region_to_lock.l_start = 16;
        region_to_lock.l_len = 5;
        printf("Process %d, trying F_WRLCK, region %d to %d\n", getpid(),
               (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));
        res = fcntl(file_desc, F_SETLK, ®ion_to_lock);
        if (res == -1) {
            printf("Process %d - failed to lock region\n", getpid());
        } else {
            printf("Process %d - obtained lock on region\n", getpid());
        }
    
        region_to_lock.l_type = F_RDLCK;
        region_to_lock.l_whence = SEEK_SET;
        region_to_lock.l_start = 40;
        region_to_lock.l_len = 10;
        printf("Process %d, trying F_RDLCK, region %d to %d\n", getpid(),
               (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));
        res = fcntl(file_desc, F_SETLK, ®ion_to_lock);
        if (res == -1) {
            printf("Process %d - failed to lock region\n", getpid());
        } else {
            printf("Process %d - obtained lock on region\n", getpid());
        }
        
        region_to_lock.l_type = F_WRLCK;
        region_to_lock.l_whence = SEEK_SET;
        region_to_lock.l_start = 16;
        region_to_lock.l_len = 5;
        printf("Process %d, trying F_WRLCK with wait, region %d to %d\n", getpid(),
               (int)region_to_lock.l_start, (int)(region_to_lock.l_start + region_to_lock.l_len));
        res = fcntl(file_desc, F_SETLKW, ®ion_to_lock);
        if (res == -1) {
            printf("Process %d - failed to lock region\n", getpid());
        } else {
            printf("Process %d - obtained lock on region\n", getpid());
        }
    
        printf("Process %d ending\n", getpid());    
        close(file_desc);
        exit(EXIT_SUCCESS);
    }
    


    其他锁的命令
    #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文件锁定

    千次阅读 2015-04-01 16:33:10
    一、什么是文件锁定 对于锁这个字,大家一定不会陌生,因为我们生活中就存在着大量的锁,它们各个方面发挥着它的作用,现在世界中的锁的功能都可归结为一句话,就是阻止某些人做某些事,例如,门锁就是阻止除了屋主...
    一、什么是文件锁定
    对于锁这个字,大家一定不会陌生,因为我们生活中就存在着大量的锁,它们各个方面发挥着它的作用,现在世界中的锁的功能都可归结为一句话,就是阻止某些人做某些事,例如,门锁就是阻止除了屋主之外的人进入这个房子,你进入不到这个房子,也就不能使用房子里面的东西。

    而因为程序经常需要共享数据,而这通常又是通过文件来实现的,试想一个情况,A进程正在对一个文件进行写操作,而另一个程序B需要对同一个文件进行读操作,并以读取到的数据作为自己程序运行时所需要的数据,这会发生什么情况呢?进程B可能会读到错乱的数据,因为它并不知道另一个进程A正在改写这个文件中的数据。

    为了解决类似的问题,就出现了文件锁定,简单点来说,这是文件的一种安全的更新方式,当一个程序正在对文件进行写操作时,文件就会进入一种暂时状态,在这个状态下,如果另一个程序尝试读这个文件,它就会自动停下来等待这个状态结束。Linux系统提供了很多特性来实现文件锁定,其中最简单的方法就是以原子操作的方式创建锁文件。

    用回之前的例子就是,文件锁就是当文件在写的时候,阻止其他的需要写或者要读文件的进程来操作这个文件。

    二、创建锁文件
    创建一个锁文件是非常简单的,我们可以使用open系统调用来创建一个锁文件,在调用open时oflags参数要增加参数O_CREAT和O_EXCL标志,如file_desc = open("/tmp/LCK.test", O_RDWR|O_CREAT|O_EXCL, 0444);就可以创建一个锁文件/tmp/LCK.test。O_CREAT|O_EXCL,可以确保调用者可以创建出文件,使用这个模式可以防止两个程序同时创建同一个文件,如果文件(/tmp/LCK.test)已经存在,则open调用就会失败,返回-1。

    如果一个程序在它执行时,只需要独占某个资源一段很短的时间,这个时间段(或代码区)通常被叫做临界区,我们需要在进入临界区之前使用open系统调用创建锁文件,然后在退出临界区时用unlink系统调用删除这个锁文件。

    注意:锁文件只是充当一个指示器的角色,程序间需要通过相互协作来使用它们,也就是说锁文件只是建议锁,而不是强制锁,并不会真正阻止你读写文件中的数据。

    可以看看下面的例子:源文件文件名为filelock1.c,代码如下:
    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.     const char *lock_file = "/tmp/LCK.test1";  
    10.     int n_fd = -1;  
    11.     int n_tries = 10;  
    12.   
    13.     while(n_tries--)  
    14.     {  
    15.                 //创建锁文件  
    16.         n_fd = open(lock_file, O_RDWR|O_CREAT|O_EXCL, 0444);  
    17.         if(n_fd == -1)  
    18.         {  
    19.                         //创建失败  
    20.             printf("%d - Lock already present\n", getpid());  
    21.             sleep(2);  
    22.         }  
    23.         else  
    24.         {                      
    25. //创建成功  
    26.             printf("%d - I have exclusive access\n", getpid());  
    27.             sleep(1);  
    28.             close(n_fd);  
    29.                         //删除锁文件,释放锁  
    30.             unlink(lock_file);  
    31.             sleep(2);  
    32.         }  
    33.     }  
    34.     return 0;  
    35. }  
    同时运行同一个程序的两个实例,运行结果为:

    从运行的结果可以看出两个程序交叉地对对文件进行锁定,但是真实的操作却是,每次调用open函数去检查/tmp/LCK.test1这个文件是否存在,如果存在open调用就失败,显示有进程已经把这个文件锁定了,如果这个文件不存在,就创建这个文件,并显示许可信息。但是这种做法有一定的缺憾,我们可以看到文件/tmp/LCK.test1被创建了很多次,也被unlink删除了很多次,也就是说我们不能使用已经事先有数据的文件作为这种锁文件,因为如果文件已经存在,则open调用总是失败。

    给我的感觉是,这更像是一种对进程工作的协调性安排,更像是二进制信号量的作用,文件存在为0,不存在为1,而不是真正的文件锁定。

    三、区域锁定
    我们还有一个问题,就是如果同一个文件有多个进程需要对它进行读写,而一个文件同一时间只能被一个进程进行写操作,但是多个进程读写的区域互不相关,如果总是要等一个进程写完其他的进程才能对其进行读写,效率又太低,那么是否可以让多个进程同时对文件进行读写以提高数据读写的效率呢?

    为了解决上面提到的问题,和出现在第二点中的问题,即不能把文件锁定到指定的已存在的数据文件上的问题,我们提出了一种新的解决方案,就是区域锁定。

    简单点来说,区域锁定就是,文件中的某个部分被锁定了,但其他程序可以访问这个文件中的其他部分。

    然而,区域锁定的创建和使用都比上面说的文件锁定复杂很多。

    1、创建区域锁定
    在Linux上为实现这一功能,我们可以使用fcntl系统调用和lockf调用,但是下面以fcntl系统调用来讲解区域锁定的创建。

    fctnl的函数原理为:
    int fctnl(int fildes, int command, ...);
    它对一个打开的文件描述进行操作,并能根据command参数的设置完成不同的任务,它有三个可选的任务:F_GETLK,F_SETLK,F_SETLKW,至于这三个参数的意义下面再详述。而当使用这些命令时,fcntl的第三个参数必须是一个指向flock结构的指针,所以在实际应用中,fctnl的函数原型一般为:int fctnl(int fildes, int command, struct flock *flock_st);

    2、flock结构

    准确来说,flock结构依赖具体的实现,但是它至少包括下面的成员:
    short l_type;文件锁的类型,对应于F_RDLCK(读锁,也叫共享锁),F_UNLCK(解锁,也叫清除锁),F_WRLCK(写锁,也叫独占锁)中的一个。

    short l_whence;从文件的哪个相对位置开始计算,对应于SEEK_SET(文件头),SEEK_CUR(当前位置),SEEK_END(文件尾)中的一个。

    off_t l_start;从l_whence开始的第l_start个字节开始计算。

    off_t l_len;锁定的区域的长度。

    pid_t l_pid;用来记录参持有锁的进程。

    成员l_whence、l_start和l_len定义了一个文件中的一个区域,即一个连续的字节集合, 例如
    struct flock region;
    region.l_whence = SEEK_SET;
    region.l_start = 10;
    region.l_len = 20;

    则表示fcntl函数操作锁定的区域为文件头开始的第10到29个字节之间的这20个字节。

    3、文件锁的类型
    从上面的flock的成员l_type的取值我们可以知道,文件锁的类型主要有三种,这里对他们进行详细的解说。

    F_RDLCK
    从它的名字我们就可以知道,它是一个读锁,也叫共享锁。许多不同的进程可以拥有文件同一(或重叠)区域上的读(共享)锁。而且只要任一进程拥有一把读(共享)锁,那么就没有进程可以再获得该区域上的写(独占)锁。为了获得一把共享锁,文件必须以“读”或“读/写”方式打开。

    简单点来说就是,当一个进程在读文件中的数据时,文件中的数据不能被改变或改写,这是为了防止数据被改变而使读数据的程序读取到错乱的数据,而文件中的同一个区域能被多个进程同时读取,这是容易理解的,因为读不会破坏数据,或者说读操作不会改变文件的数据。

    F_WRLCK
    从它的名字,我们就可以知道,它是一个写锁,也叫独占锁。只有一个进程可以在文件中的任一特定区域拥有一把写(独占)锁。一旦一个进程拥有了这样一把锁,任何其他进程都无法在该区域上获得任何类型的锁。为了获得一把写(独占)锁,文件也必须以“读”或“读/写”方式打开。

    简单点来说,就是一个文件同一区域(或重叠)区域进在同一时间,只能有一个进程能对其进行写操作,并且在写操作进行期间,其他的进程不能对该区域进行读取数据。这个要求是显然易见的,因为如果两个进程同时对一个文件进行写操作,就会使文件的内容错乱起来,而由于写时会改变文件中的数据,所以它也不允许其他进程对文件的数据进行读取和删除文件等操作。

    F_UNLCK:
    从它的名字就可以知道,它用于把一个锁定的区域解锁。

    4、不同的command的意义
    在前面说到fcntl函数的command参数时,说了三个命令选项,这里将对它们进行详细的解说。

    F_GETLK命令,它用于获取fildes(fcntl的第一个参数)打开的文件的锁信息,它不会尝试去锁定文件,调用进程可以把自己想创建的锁类型信息传递给fcntl,函数调用就会返回将会阻止获取锁的任何信息,即它可以测试你想创建的锁是否能成功被创建。fcntl调用成功时,返回非-1,如果锁请求可以成功执行,flock结构将保持不变,如果锁请求被阻止,fcntl会用相关的信息覆盖flock结构。失败时返回-1。

    所以,如果调用成功,调用程序则可以通过检查flock结构的内容来判断其是否被修改过,来检查锁请求能否被成功执行,而又因为l_pid的值会被设置成拥有锁的进程的标识符,所以大多数情况下,可以通过检查这个字段是否发生变化来判断flock结构是否被修改过。

    使用F_GETLK的fcntl函数调用后会立即返回。

    举个例子来说,例如,有一个flock结构的变量,flock_st,flock_st.l_pid = -1,文件的第10~29个字节已经存在一个读锁,文件的第40~49个字节中已经存在一个写锁,则调用fcntl时,如果用F_GETLK命令,来测试在第10~29个字节中是否可以创建一个读锁,因为这个锁可以被创建,所以,fcntl返回非-1,同时,flock结构的内容也不会改变,flock_st.l_pid = -1。而如果我们测试第40~49个字节中是否可以创建一个写锁时,由于这个区域已经存在一个写锁,测试失败,但是fcntl还是会返回非-1,只是flock结构会被这个区域相关的锁的信息覆盖了,flock_st.l_pid为拥有这个写锁的进程的进程标识符。

    F_SETLK命令,这个命令试图对fildes指向的文件的某个区域加锁或解锁,它的功能根据flock结构的l_type的值而定。而对于这个命令来说,flock结构的l_pid字段是没有意义的。如果加锁成功,返回非-1,如果失败,则返回-1。使用F_SETLK的fcntl函数调用后会立即返回。

    F_SETLKW命令,这个命令与前面的F_SETLK,命令作用相同,但不同的是,它在无法获取锁时,即测试不能加锁时,会一直等待直到可以被加锁为止。

    5、例子
    看了这么多的说明,可能你已经很乱了,就用下面的例子来整清你的思想吧。
    源文件名为filelock2.c,用于创建数据文件,并将文件区域加锁,代码如下:
    1. #include <unistd.h>  
    2. #include <stdlib.h>  
    3. #include <stdio.h>  
    4. #include <fcntl.h>  
    5.   
    6. int main()  
    7. {  
    8.     const char *test_file = "test_lock.txt";  
    9.     int file_desc = -1;  
    10.     int byte_count = 0;  
    11.     char *byte_to_write = "A";  
    12.     struct flock region_1;  
    13.     struct flock region_2;  
    14.     int res = 0;  
    15.   
    16.     //打开一个文件描述符   
    17.     file_desc = open(test_file, O_RDWR|O_CREAT, 0666);  
    18.     if(!file_desc)  
    19.     {  
    20.         fprintf(stderr, "Unable to open %s for read/write\n", test_file);  
    21.         exit(EXIT_FAILURE);  
    22.     }  
    23.     //给文件添加100个‘A’字符的数据  
    24.     for(byte_count = 0; byte_count < 100; ++byte_count)  
    25.     {  
    26.         write(file_desc, byte_to_write, 1);  
    27.     }  
    28.     //在文件的第10~29字节设置读锁(共享锁)  
    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.     //在文件的40~49字节设置写锁(独占锁)  
    34.     region_2.l_type = F_WRLCK;  
    35.     region_2.l_whence = SEEK_SET;  
    36.     region_2.l_start = 40;  
    37.     region_2.l_len = 10;  
    38.   
    39.     printf("Process %d locking file\n", getpid());  
    40.     //锁定文件  
    41.     res = fcntl(file_desc, F_SETLK, &region_1);  
    42.     if(res == -1)  
    43.     {  
    44.         fprintf(stderr, "Failed to lock region 1\n");  
    45.     }  
    46.     res = fcntl(file_desc, F_SETLK, &region_2);  
    47.     if(res == -1)  
    48.     {  
    49.         fprintf(stderr, "Failed to lock region 2\n");  
    50.     }  
    51.     //让程序休眠一分钟,用于测试  
    52.     sleep(60);  
    53.     printf("Process %d closing file\n", getpid());  
    54.     close(file_desc);  
    55.     exit(EXIT_SUCCESS);  
    56. }  

    下面的源文件filelock3.c用于测试上一个文件设置的锁,测试可否对两个区域都加上一个读锁,代码如下:
    1. #include <unistd.h>  
    2. #include <stdlib.h>  
    3. #include <stdio.h>  
    4. #include <fcntl.h>  
    5.   
    6. int main()  
    7. {  
    8.     const char *test_file = "test_lock.txt";  
    9.     int file_desc = -1;  
    10.     int byte_count = 0;  
    11.     char *byte_to_write = "A";  
    12.     struct flock region_1;  
    13.     struct flock region_2;  
    14.     int res = 0;  
    15.     //打开数据文件  
    16.     file_desc = open(test_file, O_RDWR|O_CREAT, 0666);  
    17.     if(!file_desc)  
    18.     {  
    19.         fprintf(stderr, "Unable to open %s for read/write\n", test_file);  
    20.         exit(EXIT_FAILURE);  
    21.     }  
    22.     //设置区域1的锁类型  
    23.     struct flock region_test1;  
    24.     region_test1.l_type = F_RDLCK;  
    25.     region_test1.l_whence = SEEK_SET;  
    26.     region_test1.l_start = 10;  
    27.     region_test1.l_len = 20;  
    28.     region_test1.l_pid = -1;  
    29.     //设置区域2的锁类型  
    30.     struct flock region_test2;  
    31.     region_test2.l_type = F_RDLCK;  
    32.     region_test2.l_whence = SEEK_SET;  
    33.     region_test2.l_start = 40;  
    34.     region_test2.l_len = 10;  
    35.     region_test2.l_pid = -1;  
    36.     //对区域1的是否可以加一个读锁进行测试  
    37.     res = fcntl(file_desc, F_GETLK, &region_test1);  
    38.     if(res == -1)  
    39.     {  
    40.         fprintf(stderr, "Failed to get RDLCK\n");  
    41.     }  
    42.     if(region_test1.l_pid == -1)  
    43.     {  
    44.         //可以加一个读锁  
    45.         printf("test: Possess %d could lock\n", getpid());  
    46.     }  
    47.     else  
    48.     {  
    49.         //不允许加一个读锁  
    50.         printf("test:Prossess %d  get lock failure\n", getpid());  
    51.     }  
    52.   
    53.     //对区域2是否可以加一个读锁进行测试  
    54.     res = fcntl(file_desc, F_GETLK, &region_test2);  
    55.     if(res == -1)  
    56.     {  
    57.         fprintf(stderr, "Failed to get RDLCK\n");  
    58.     }  
    59.     if(region_test2.l_pid == -1)  
    60.     {  
    61.         //可以加一个读锁  
    62.         printf("test: Possess %d could lock\n", getpid());  
    63.     }  
    64.     else  
    65.     {  
    66.         //不允许加一个读锁  
    67.         printf("test:Prossess %d  get lock failure\n", getpid());  
    68.     }  
    69.     exit(EXIT_SUCCESS);  
    70. }  

    运行结果如下:


    因为区域1中存在的是读锁,所以在其之上再加一个读锁是可以成功的,然而区域2上存在的锁是写锁,在其上不能加任何类型的锁,所以测试失败。注意,测试失败并不是fctnl调用失败,它还是返回非-1,我们是通过检查flock结构的成员l_pid来确定测试结果的。

    三、解空锁问题
    如果我要给在本进程中没有加锁的区域解锁会发生什么事情呢?而如果这个区域中其他的进程有对其进行加锁又会发生什么情况呢?

    如果一个进程实际并未对一个区域进行锁定,而调用解锁操作也会成功,但是它并不能解其他的进程加在同一区域上的锁。也可以说解锁请求最终的结果取决于这个进程在文件中设置的任何锁,没有加锁,但对其进行解锁得到的还是没有加锁的状态。
    展开全文
  • 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 这些文件上锁后,任何用户...
  • #避免服务器进行误操作 #不允许文件做任何操作 chattr +i /etc/passwd /etc/shadow /etc/group /etc/gshadow /etc/inittab -i为取消 lsattr 查看文件属性
  • Linux数据管理——文件锁定

    千次阅读 2013-08-19 16:23:20
    一、什么是文件锁定 对于锁这个字,大家一定不会陌生,因为我们生活中就存在着大量的锁,它们各个方面发挥着它的作用,现在世界中的锁的功能都可归结为一句话,就是阻止某些人做某些事,例如,门锁就是阻止除了屋主...
  • --用户被锁定 多次认证失败 解决办法 pam_tally2 -u username --reset   --修改文件修改时间 touch -t 201801010728 fileName   --查看文件修改时间 stat IOT_IOT_DDR* | grep -i Modify | awk -F. '{print...
  • 锁定关键文件,增强Linux安全性.pdf
  • Linux文件执行中的锁定的怪现象.docx
  • Linux文件执行中的锁定怪现象解释.docx
  • Linux命令-文件锁定命令chattr与lsattr

    千次阅读 2017-03-29 22:14:16
    PS:有时候你发现用root权限都不能修改某个文件,大部分原因是曾经用chattr命令锁定文件了。chattr命令的作用很大,其中一些功能是由Linux内核版本来支持的,不过现在生产绝大部分跑的linux系统都是2.6以上内核了...
  • ./lock_test Process 11080 has the lock.
  • Linux 虚拟机报错:另一个程序已锁定文件的一部分,进程无法访问。。0x00 问题0x01 原因0x02 解决 0x00 问题 •另一个程序已锁定文件的一部分,进程无法访问(或者:锁定文件失败 ) •打不开磁盘“。。。”或它所...
  • Linux文件执行中的锁定的怪现象

    千次阅读 2011-12-06 21:27:35
    本来今天不准备开电脑了,太困...问题如下:linux下,一个可执行文件exe1正在执行中,rm –f可以将其删除,mv可以将其移除,mv $other exe1也可以将其替换,但是cp $other exe1则显示文件忙,求解。这实际上并不是一个
  • Linux文件系统目录结构详解

    万次阅读 2017-10-08 13:09:34
    对于每一个Linux学习者来说,了解Linux文件系统的目录结构,是学好Linux的至关重要的一步.,深入了解linux文件目录结构的标准和每个目录的详细功能,对于我们用好linux系统只管重要,下面我们就开始了解一下linux...
  • Linux 文件

    千次阅读 2013-11-04 19:59:58
    文件锁简介: Linux中,在文件共享的情况下如何对文件...在Linux中,实现文件上锁的函数有flock()和fcntl(),其中flock()只能锁定整个文件,无法锁定文件的某一区域,而fcntl()不仅可以锁定整个文件,还可以只锁定文件
  • 为了使我们的linux系统更安全,减少黑客入侵的可能性,可以使用chattr命令对系统中的关键文件进行锁定。如: #chattr +i /etc/passwd /etc/shadow /etc/groupp /etc/gshadow  将系统中的passwd,shadow,group....
  •  linux对账户的锁定功能比windows的要更加广泛,强大,windows组策略中的限制,只是在系统层面的限制,而linux借助pam(Pluggable Authentication Modules,插件式认证模块)的强大,不单止可以系统层面实现,还能在...
  • Linux文件权限详解

    万次阅读 多人点赞 2018-12-30 19:57:00
    文章目录Linux文件权限详解一、文件权限二、修改文件访问权限的方法三、UMASK值四、三种特殊权限suid、sgid、sticky(sticky权限工作环境中相对常用)五、ACL访问控制列表六、文件权限操作的常用命令 Linux文件权限...
  • d:当dump程序执行时,该文件或目录不会dump备份。 D:检查压缩文件中的错误。 i:即Immutable,系统不允许对这个文件进行任何的修改。如果目录具有这个属性,那么任何的进程只能修改目录之下的文件,不允许...
  • Linux文件---文件锁

    千次阅读 2017-09-02 17:03:12
    对于文件的操作而言,“锁定”操作是对文件(尤其是对共享文件)的一种高级的文件操作。当某进程在更新文件内数据时,期望某种机制能防止多个进程同时更新文件从而导致数据丢失,或者防止文件内容在未更新完毕时...
  • Linux 文件类型 及文件的扩展名作者:北南南北来自:LinuxSir.Org摘要: Linux文件类型常见的有:普通文件、目录、字符设备文件、块设备文件、符号链接文件等,如果想了解这方面知识的弟兄,就进来了解了解。...
  • Linux文件

    万次阅读 2013-12-05 19:55:06
    翻阅参考资料,你会发现文件锁可以进行很多的分类,最常见的主要有读锁与写锁,前者也叫共享锁,后者也叫排斥锁,值得注意的是,多个读锁之间是不会相互干扰的,多个进程可以在同一时刻对同一个文件加读锁;...
  • Linux文件管理

    千次阅读 2019-01-28 13:13:49
    Linux上的文件管理类命令都有哪些,其常用的使用方法及其相关示例演示。 使用命令行展开功能,创建/tmp/a1, /tmp/a2, /tmp/a1/a, /tmp/a1/b,在/tmp目录下创建目录:x_y, x_z, q_y, q_z 文件的元数据信息有哪些,...
  • linux 文件目录结构

    千次阅读 2015-04-28 22:40:31
    对于每一个Linux学习者来说,了解Linux文件系统的目录结构,是学好Linux的至关重要的一步.,深入了解linux文件目录结构的标准和每个目录的详细功能,对于我们用好linux系统只管重要,下面我们就开始了解一下linux...
  • Linux账户锁定策略设置

    千次阅读 2018-08-23 18:24:02
    为账户设置锁定策略是服务器安全测评里面的一个要求,windows在组策略里面可以很简单设置,linux中可以使用pam的pam_tally2.so模块来实现。  linux对账户的锁定功能比windows的要更加广泛,强大,windows组策略中的...
  • 原因:本人因在设置虚拟机时CD/DVD硬件连接方式将使用iso映像文件改成了物理驱动连接,导致VMware Linux虚拟机启动时提示“锁定文件失败...” 、 (注:期间碰到进程占用问题,解决:Ctrl+Alt+Del打开任务管理...
  • 添加文件锁定 chattr +i /etc/fstab chattr +i /etc/passwd chattr +i /etc/shadow chattr +i /etc/group chattr +i /etc/groupshadow chattr +i /etc/rc.d/rc.local chattr +i /etc/profile chattr +i /etc/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,924
精华内容 35,169
关键字:

linux文件被锁定

linux 订阅