Chinaunix首页 | 论坛 | 博客

oops

首页　| 　博文目录　| 　关于我

王贤才

  • 博客访问： 1064390
  • 博文数量： 573
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 66
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-28 16:21
文章分类

全部博文（573）

文章存档

2018年（3）

2016年（48）

2015年（522）

我的朋友
最近访客
推荐博文
相关博文
文件锁

分类： LINUX

2015-12-02 16:23:29

flock.c文件

点击(此处)折叠或打开

  1. #include <unistd.h>
  2. #include <fcntl.h>
  3. #include <errno.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <stdio.h>

  8. //设置读锁
  9. #define read_lock(fd, offset, whence, len) \
  10.                 lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
  11. //设置读锁阻塞
  12. #define readw_lock(fd, offset, whence, len) \
  13.                 lock_reg((fd), F_SETLKW, F_RDLCK, (offset), (whence), (len))
  14. //设置写锁
  15. #define write_lock(fd, offset, whence, len) \
  16.                 lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
  17. //设置写锁阻塞
  18. #define writew_lock(fd, offset, whence, len) \
  19.                 lock_reg((fd), F_SETLKW, F_WRLCK, (offset), (whence), (len))
  20. //解锁
  21. #define un_lock(fd, offset, whence, len) \
  22.                 lock_reg((fd), F_SETLKW, F_UNLCK, (offset), (whence), (len))



  26. //测试能否新建读锁
  27. #define is_read_lockable(fd, offset, whence, len) \
  28.                 (lock_test((fd), F_RDLCK, (offset), (whence), (len)) == 0)
  29. //测试能否新建写锁
  30. #define is_write_lockable(fd, offset, whence, len) \
  31.                 (lock_test((fd), F_WRLCK, (offset), (whence), (len)) == 0)



  35. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len);
  36. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len);

  38. int main(int argc, char * * argv)
  39. {
  40.         int ret;
  41.         int fd;
  42.         fd = open("/home/eas/src/API_fun/Trans_910100.xml", O_RDWR, 777);
  43.         if(fd < 0)
  44.         {
  45.                 printf("open err!\n");
  46.                 return -1;
  47.         }
  48.         /*
  49.         如果另外有一个进程对这个文件设置了写锁，表明有进程正在写文件。
  50.         下面的write也是可以写数据进文件的，
  51.         这样就违背了单独写一个文件的规则，不是我们想要的。如果要确保写文件的时候只有一个进程单独在写，
  52.         约定所有进程在写文件之前也尝试设置一把写锁(查看现在能否写该文件)，
  53.         如果写锁设置成功，则表示没有其他进程在写该文件，本进程可以写了，
  54.         如果写锁设置失败，则表示有其他进程在写该文件，本进程不必执行write了，非要执行也可以写数据进文件。
  55.         */
  56.         ret = write(fd, "wangxc", strlen("wangxc"));
  57.         if(ret > 0)
  58.         {
  59.                 printf("成功写[%d]个字节数据到文件[/home/eas/src/API_fun/Trans_910100.xml]\n", ret);
  60.         }
  61.         /*
  62.         判断fd文件能否建立一把独占性写锁：如果排斥锁存在：则把现在已有锁的信息写到flockptr指向的结构中去。
  63.         如果排斥锁不存在：则将l_type设置为F_UNLCK。
  64.         只说明：指定的锁不被现有的锁排斥，并不是说该区域没有锁,该区域可能有锁但不排斥新锁，也可能没有锁;
  65.         */
  66.         if(is_read_lockable(fd, 0, SEEK_SET, 0))
  67.         {
  68.                 printf("进程[%d],能新建读锁！\n", getpid());
  69.         }
  70.         else
  71.         {
  72.                 printf("进程[%d],不能新建读锁！\n", getpid());
  73.         }
  74.         
  75.         //设置读锁
  76.         ret = read_lock(fd, 0, SEEK_SET, 0);
  77.         printf("ret = [%d]\n", ret);
  78.         if(ret == 0)
  79.         {
  80.                 printf("进程[%d]，对文件Trans_910100.xml，设置读锁成功!\n", getpid());
  81.         }
  82.         else
  83.         {
  84.                 printf("read_lock err!\n");
  85.         }
  86.         
  87.         //while(1);
  88.         
  89.         return 0;
  90. }



  94. /*

  96. */
  97. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
  98. {
  99.         struct flock lock;
  100.         
  101.         lock.l_type = type;
  102.         lock.l_start = offset;
  103.         lock.l_whence = whence;
  104.         lock.l_len = len;
  105.         
  106.         return(fcntl(fd, cmd, &lock));
  107. }

  109. //测试锁状态
  110. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len)
  111. {
  112.         struct flock lock;
  113.         
  114.         lock.l_type = type;
  115.         lock.l_start = offset;
  116.         lock.l_whence = whence;
  117.         lock.l_len = len;
  118.         
  119.         int ret;
  120.         ret = fcntl(fd, F_GETLK, &lock);
  121.         if(ret < 0)
  122.         {
  123.                 printf("fcntl F_GETLK err!\n");
  124.         }
  125.         
  126.         if(lock.l_type == F_UNLCK)
  127.         {
  128.                 printf("排斥锁不存在：则将l_type设置为F_UNLCK!该区域可能有锁但不排斥新锁，也可能没有锁!\n");
  129.                 return 0;
  130.         }
  131.                 
  132.         return(lock.l_pid);
  133. }
flock2.c文件

点击(此处)折叠或打开

  1. #include <unistd.h>
  2. #include <fcntl.h>
  3. #include <errno.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <stdio.h>

  8. //设置读锁
  9. #define read_lock(fd, offset, whence, len) \
  10.                 lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
  11. //设置读锁阻塞
  12. #define readw_lock(fd, offset, whence, len) \
  13.                 lock_reg((fd), F_SETLKW, F_RDLCK, (offset), (whence), (len))
  14. //设置写锁
  15. #define write_lock(fd, offset, whence, len) \
  16.                 lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
  17. //设置写锁阻塞
  18. #define writew_lock(fd, offset, whence, len) \
  19.                 lock_reg((fd), F_SETLKW, F_WRLCK, (offset), (whence), (len))
  20. //解锁
  21. #define un_lock(fd, offset, whence, len) \
  22.                 lock_reg((fd), F_SETLKW, F_UNLCK, (offset), (whence), (len))

  24. //测试能否新建读锁
  25. #define is_read_lockable(fd, offset, whence, len) \
  26.                 (lock_test((fd), F_RDLCK, (offset), (whence), (len)) == 0)
  27. //测试能否新建写锁
  28. #define is_write_lockable(fd, offset, whence, len) \
  29.                 (lock_test((fd), F_WRLCK, (offset), (whence), (len)) == 0)



  33. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len);
  34. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len);

  36. int main(int argc, char * * argv)
  37. {
  38.         int ret;
  39.         int fd;
  40.         fd = open("/home/eas/src/API_fun/Trans_910100.xml", O_RDWR, 777);
  41.         if(fd < 0)
  42.         {
  43.                 printf("open err!\n");
  44.                 return -1;
  45.         }
  46.         //write(fd, "wangxc", strlen("wangxc"));
  47.         //测试能否加写锁
  48.         if(is_write_lockable(fd, 0, SEEK_SET, 0))
  49.         {
  50.                 printf("进程[%d],能新建写锁！\n", getpid());
  51.         }
  52.         else
  53.         {
  54.                 printf("进程[%d],不能新建写锁！\n", getpid());
  55.         }
  56.         
  57.         //设置写锁
  58.         printf("设置写锁！\n");
  59.         ret = write_lock(fd, 0, SEEK_SET, 0);
  60.         printf("ret = [%d]\n", ret);
  61.         if(ret == 0)
  62.         {
  63.                 printf("进程[%d]，对文件Trans_910100.xml，设置写锁成功!\n", getpid());
  64.         }
  65.         else
  66.         {
  67.                 printf("write_lock err!\n");
  68.         }
  69.         
  70.         while(1);
  71.         
  72.         int i = 0;
  73.         while(i < 20)
  74.         {
  75.                 printf("sleep(1)!\n");
  76.                 sleep(1);
  77.                 i++;
  78.         }
  79.         
  80.         return 0;
  81. }



  85. /*

  87. */
  88. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
  89. {
  90.         struct flock lock;
  91.         
  92.         lock.l_type = type;
  93.         lock.l_start = offset;
  94.         lock.l_whence = whence;
  95.         lock.l_len = len;
  96.         
  97.         return(fcntl(fd, cmd, &lock));
  98. }

  100. //测试锁状态
  101. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len)
  102. {
  103.         struct flock lock;
  104.         
  105.         lock.l_type = type;
  106.         lock.l_start = offset;
  107.         lock.l_whence = whence;
  108.         lock.l_len = len;
  109.         
  110.         int ret;
  111.         ret = fcntl(fd, F_GETLK, &lock);
  112.         if(ret < 0)
  113.         {
  114.                 printf("fcntl F_GETLK err!\n");
  115.         }
  116.         
  117.         if(lock.l_type == F_UNLCK)
  118.         {
  119.                 printf("排斥锁不存在：则将l_type设置为F_UNLCK!该区域可能有锁但不排斥新锁，也可能没有锁!\n");
  120.                 return 0;
  121.         }
  122.                 
  123.         return(lock.l_pid);
  124. }
flock3.c文件

点击(此处)折叠或打开

  1. #include <unistd.h>
  2. #include <fcntl.h>
  3. #include <errno.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <stdio.h>

  8. //设置读锁
  9. #define read_lock(fd, offset, whence, len) \
  10.                 lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
  11. //设置读锁阻塞
  12. #define readw_lock(fd, offset, whence, len) \
  13.                 lock_reg((fd), F_SETLKW, F_RDLCK, (offset), (whence), (len))
  14. //设置写锁
  15. #define write_lock(fd, offset, whence, len) \
  16.                 lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
  17. //设置写锁阻塞
  18. #define writew_lock(fd, offset, whence, len) \
  19.                 lock_reg((fd), F_SETLKW, F_WRLCK, (offset), (whence), (len))
  20. //解锁
  21. #define un_lock(fd, offset, whence, len) \
  22.                 lock_reg((fd), F_SETLKW, F_UNLCK, (offset), (whence), (len))

  24. //测试能否新建读锁
  25. #define is_read_lockable(fd, offset, whence, len) \
  26.                 (lock_test((fd), F_RDLCK, (offset), (whence), (len)) == 0)
  27. //测试能否新建写锁
  28. #define is_write_lockable(fd, offset, whence, len) \
  29.                 (lock_test((fd), F_WRLCK, (offset), (whence), (len)) == 0)

  31. int lockfile(int fd);

  33. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len);
  34. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len);

  36. int main(int argc, char * * argv)
  37. {
  38.         int ret;
  39.         int fd;
  40.         fd = open("/home/eas/src/API_fun/Trans_910100.xml", O_RDWR, 777);
  41.         if(fd < 0)
  42.         {
  43.                 printf("open err!\n");
  44.                 return -1;
  45.         }
  46.         //write(fd, "wangxc", strlen("wangxc"));
  47.         //测试能否加写锁
  48.         if(is_write_lockable(fd, 0, SEEK_SET, 0))
  49.         {
  50.                 printf("进程[%d],能新建写锁！\n", getpid());
  51.         }
  52.         else
  53.         {
  54.                 printf("进程[%d],不能新建写锁！\n", getpid());
  55.         }
  56.         
  57.         //设置写锁阻塞
  58.         printf("设置写锁阻塞！\n");
  59.         ret = writew_lock(fd, 0, SEEK_SET, 0);
  60.         printf("ret = [%d]\n", ret);
  61.         if(ret == 0)
  62.         {
  63.                 printf("进程[%d]，对文件Trans_910100.xml，设置写锁成功!\n", getpid());
  64.         }
  65.         else
  66.         {
  67.                 printf("writew_lock err!\n");
  68.         }
  69.         
  70.         while(1);
  71.         
  72.         return 0;
  73. }

  75. /**
  76. 功能：给文件整体上加一把写锁
  77. 等同于：#define lockfile(fd) writew_lock((fd), 0, SEEK_SET, 0)
  78. **/
  79. int lockfile(int fd)
  80. {
  81.         struct flock lock;
  82.         
  83.         lock.l_type = F_WRLCK;
  84.         lock.l_start = 0;
  85.         lock.l_whence = SEEK_SET;
  86.         lock.l_len = 0;
  87.         
  88.         return(fcntl(fd, F_SETLK, &lock));
  89. }



  93. /*

  95. */
  96. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
  97. {
  98.         struct flock lock;
  99.         
  100.         lock.l_type = type;
  101.         lock.l_start = offset;
  102.         lock.l_whence = whence;
  103.         lock.l_len = len;
  104.         
  105.         return(fcntl(fd, cmd, &lock));
  106. }

  108. //测试锁状态
  109. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len)
  110. {
  111.         struct flock lock;
  112.         
  113.         lock.l_type = type;
  114.         lock.l_start = offset;
  115.         lock.l_whence = whence;
  116.         lock.l_len = len;
  117.         
  118.         int ret;
  119.         ret = fcntl(fd, F_GETLK, &lock);
  120.         if(ret < 0)
  121.         {
  122.                 printf("fcntl F_GETLK err!\n");
  123.         }
  124.         
  125.         if(lock.l_type == F_UNLCK)
  126.         {
  127.                 printf("排斥锁不存在：则将l_type设置为F_UNLCK!该区域可能有锁但不排斥新锁，也可能没有锁!\n");
  128.                 return 0;
  129.         }
  130.                 
  131.         return(lock.l_pid);
  132. }
flock4.c文件

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/stat.h>
  5. #include <unistd.h>
  6. #include <fcntl.h>
  7. #include <errno.h>

  9. int SetEnforceLock(char * file);
  10. int lockfile(int fd);

  12. int main(int argc, char * * argv)
  13. {
  14.         char filename[128];
  15.         int fd;
  16.         
  17.         memset(filename, 0, sizeof(filename));
  18.         strcpy(filename, "/home/eas/src/API_fun/Trans_910100.xml");
  19.         
  20.         SetEnforceLock(filename);
  21.         
  22.         fd = open(filename, O_RDWR, 0777);
  23.         if(fd < 0)
  24.         {
  25.                 printf("open errr!\n");
  26.                 exit(0);
  27.         }
  28.         lockfile(fd);
  29.         
  30.         printf("errno = [%d]\n", errno);
  31.         
  32.         while(1);
  33.         
  34.         
  35.         return 0;
  36. }


  39. /*
  40. 对指定的文件，开启强制性锁机制
  41. */
  42. int SetEnforceLock(char * file)
  43. {
  44.         int ret = -1;
  45.         struct stat statbuf;
  46.         
  47.         ret = stat(file, &statbuf);
  48.         if(ret < 0)
  49.         {
  50.                 printf("stat err!\n");
  51.                 return -1;
  52.         }
  53.         
  54.         ret = chmod(file, (statbuf.st_mode & ~S_IXGRP) | S_ISGID);
  55.         if(ret < 0)
  56.         {
  57.                 printf("chmod err!\n");
  58.                 return -1;
  59.         }
  60.         
  61.         return 0;
  62. }


  65. /**
  66. 功能：给文件整体上加锁
  67. 等同于：#define lockfile(fd) writew_lock((fd), 0, SEEK_SET, 0)
  68. **/
  69. int lockfile(int fd)
  70. {
  71.         struct flock lock;
  72.         
  73.         lock.l_type = F_WRLCK;
  74.         lock.l_start = 0;
  75.         lock.l_whence = SEEK_SET;
  76.         lock.l_len = 0;
  77.         
  78.         return(fcntl(fd, F_SETLK, &lock));
  79. }
flock5.c

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/stat.h>
  5. #include <unistd.h>
  6. #include <fcntl.h>
  7. #include <errno.h>

  9. int SetEnforceLock(char * file);
  10. int lockfile(int fd);

  12. int main(int argc, char * * argv)
  13. {
  14.         char filename[128];
  15.         int fd;
  16.         
  17.         memset(filename, 0, sizeof(filename));
  18.         strcpy(filename, "/home/eas/src/API_fun/Trans_910100.xml");
  19.         
  20.         /*lock4 程序启动后，下面的open还是能打开文件的，因为：本系统没有提供强制性记录锁*/
  21.         fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0777);
  22.         if(fd < 0)
  23.         {
  24.                 printf("open errr!\n");
  25.                 exit(0);
  26.         }
  27.         printf("errno = [%d]\n", errno);
  28.         
  29.         
  30.         return 0;
  31. }


  34. /*
  35. 对指定的文件，开启强制性锁机制
  36. */
  37. int SetEnforceLock(char * file)
  38. {
  39.         int ret = -1;
  40.         struct stat statbuf;
  41.         
  42.         ret = stat(file, &statbuf);
  43.         if(ret < 0)
  44.         {
  45.                 printf("stat err!\n");
  46.                 return -1;
  47.         }
  48.         
  49.         ret = chmod(file, (statbuf.st_mode & ~S_IXGRP) | S_ISGID);
  50.         if(ret < 0)
  51.         {
  52.                 printf("chmod err!\n");
  53.                 return -1;
  54.         }
  55.         
  56.         return 0;
  57. }


  60. /**
  61. 功能：给文件整体上加锁
  62. 等同于：#define lockfile(fd) writew_lock((fd), 0, SEEK_SET, 0)
  63. **/
  64. int lockfile(int fd)
  65. {
  66.         struct flock lock;
  67.         
  68.         lock.l_type = F_WRLCK;
  69.         lock.l_start = 0;
  70.         lock.l_whence = SEEK_SET;
  71.         lock.l_len = 0;
  72.         
  73.         return(fcntl(fd, F_SETLK, &lock));
  74. }
flock6.c

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/stat.h>
  5. #include <unistd.h>
  6. #include <fcntl.h>
  7. #include <errno.h>
  8. #include <sys/types.h>

  10. //设置读锁
  11. #define read_lock(fd, offset, whence, len) \
  12.                 lock_reg((fd), F_SETLK, F_RDLCK, (offset), (whence), (len))
  13. //设置读锁阻塞
  14. #define readw_lock(fd, offset, whence, len) \
  15.                 lock_reg((fd), F_SETLKW, F_RDLCK, (offset), (whence), (len))
  16. //设置写锁
  17. #define write_lock(fd, offset, whence, len) \
  18.                 lock_reg((fd), F_SETLK, F_WRLCK, (offset), (whence), (len))
  19. //设置写锁阻塞
  20. #define writew_lock(fd, offset, whence, len) \
  21.                 lock_reg((fd), F_SETLKW, F_WRLCK, (offset), (whence), (len))
  22. //解锁
  23. #define un_lock(fd, offset, whence, len) \
  24.                 lock_reg((fd), F_SETLKW, F_UNLCK, (offset), (whence), (len))

  26. //测试能否新建读锁
  27. #define is_read_lockable(fd, offset, whence, len) \
  28.                 (lock_test((fd), F_RDLCK, (offset), (whence), (len)) == 0)
  29. //测试能否新建写锁
  30. #define is_write_lockable(fd, offset, whence, len) \
  31.                 (lock_test((fd), F_WRLCK, (offset), (whence), (len)) == 0)

  33. int lockfile(int fd);

  35. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len);
  36. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len);

  38. int SetEnforceLock(char * file);
  39. int SetEnforceLock2(int fd);

  41. void set_fl(int fd, int flags);
  42. void clr_fl(int fd, int flags);


  45. int main(int argc, char * * argv)
  46. {
  47.         char filename[128];
  48.         char buf[128];
  49.         int fd;
  50.         int ret;
  51.         pid_t pid;
  52.         
  53.         memset(filename, 0, sizeof(filename));
  54.         strcpy(filename, "/home/eas/src/API_fun/Trans_910100.xml");
  55.         
  56.         fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0777);
  57.         if(fd < 0)
  58.         {
  59.                 printf("open errr!\n");
  60.                 exit(0);
  61.         }
  62.         printf("fd = [%d]\n", fd);
  63.         
  64.         char wbuf[1024];
  65.         memset(wbuf, 0, sizeof(wbuf));
  66.         strcpy(wbuf, "wangxc");
  67.         
  68.         write(fd, wbuf, strlen(wbuf));
  69.         printf("write buf = [%s]\n", wbuf);
  70.         
  71.         ret = SetEnforceLock2(fd);
  72.         if(ret < 0)
  73.         {
  74.                 printf("SetEnforceLock2 err!\n");
  75.                 exit(-1);
  76.         }
  77.         
  78.         pid = fork();
  79.         if(pid < 0)
  80.         {
  81.                 printf("fork err!\n");
  82.                 exit(-1);
  83.         }
  84.         else if(pid > 0)
  85.         {
  86.                 printf("这里是父进程：\n");
  87.     
  88.                 //ret = lockfile(fd); //对整个文件设置一把写锁
  89.                 ret = write_lock(fd, 0, SEEK_SET, 0);
  90.                 if(ret < 0)
  91.                 {
  92.                         printf("write_lock err!\n");
  93.                         exit(-1);
  94.                 }
  95.                 
  96.                 if(waitpid(pid, NULL, 0) < 0) //等待子进程结束
  97.                 {
  98.                         printf("waitpid err!\n");
  99.                         exit(-1);
  100.                 }
  101.                 printf("父进程结束！\n");

  103.                 exit(0);
  104.         }
  105.         else if(pid == 0)
  106.         {
  107.                 sleep(3);
  108.                 printf("这里是子进程：\n");
  109.                 
  110.                 set_fl(fd, O_NONBLOCK); //对fd设置非阻塞模式
  111.                 
  112.                 /*
  113.                 此时：父进程已经对整个文件设置了一把写锁，子进程企图去对该文件设置一把读锁：会返回出错。
  114.                 ret = read_lock(fd, 0, SEEK_SET, 0);
  115.                 if(ret < 0)
  116.                 {
  117.                         printf("read_lock err!\n");
  118.                         printf("errno = [%d][%s]\n", errno, strerror(errno));
  119.                         exit(-1);
  120.                 }
  121.                 */
  122.                 
  123.                 lseek(fd, 0, SEEK_SET);
  124.                 
  125.                 memset(filename, 0, sizeof(filename));
  126.                 read(fd, buf, sizeof(buf));
  127.                 
  128.                 /*如果buf中有数据：则说明此操作系统是不支持强制性记录锁的
  129.                 如果buf中没有数据：则说明此操作系统是支持强制性记录锁机制的*/
  130.                 printf("read buf = [%s]\n", buf);
  131.                 
  132.                 printf("子进程结束！\n");
  133.     
  134.                 exit(0);
  135.         }
  136. }

  138. /*
  139. 对指定的文件，开启强制性锁机制
  140. */
  141. int SetEnforceLock(char * file)
  142. {
  143.         int ret = -1;
  144.         struct stat statbuf;
  145.         
  146.         ret = stat(file, &statbuf);
  147.         if(ret < 0)
  148.         {
  149.                 printf("stat err!\n");
  150.                 return -1;
  151.         }
  152.         
  153.         ret = chmod(file, (statbuf.st_mode & ~S_IXGRP) | S_ISGID);
  154.         if(ret < 0)
  155.         {
  156.                 printf("chmod err!\n");
  157.                 return -1;
  158.         }
  159.         
  160.         return 0;
  161. }

  163. /*
  164. 对指定的文件，开启强制性锁机制
  165. */
  166. int SetEnforceLock2(int fd)
  167. {
  168.         int ret = -1;
  169.         struct stat statbuf;
  170.         
  171.         ret = fstat(fd, &statbuf);
  172.         if(ret < 0)
  173.         {
  174.                 printf("stat err!\n");
  175.                 return -1;
  176.         }
  177.         
  178.         ret = fchmod(fd, (statbuf.st_mode & ~S_IXGRP) | S_ISGID);
  179.         if(ret < 0)
  180.         {
  181.                 printf("chmod err!\n");
  182.                 return -1;
  183.         }
  184.         
  185.         return 0;
  186. }

  188. /**
  189. 功能：给文件整体上加一把写锁
  190. 等同于：#define lockfile(fd) writew_lock((fd), 0, SEEK_SET, 0)
  191. **/
  192. int lockfile(int fd)
  193. {
  194.         struct flock lock;
  195.         
  196.         lock.l_type = F_WRLCK;
  197.         lock.l_start = 0;
  198.         lock.l_whence = SEEK_SET;
  199.         lock.l_len = 0;
  200.         
  201.         return(fcntl(fd, F_SETLK, &lock));
  202. }

  204. /*

  206. */
  207. int    lock_reg(int fd, int cmd, int type, off_t offset, int whence, off_t len)
  208. {
  209.         struct flock lock;
  210.         
  211.         lock.l_type = type;
  212.         lock.l_start = offset;
  213.         lock.l_whence = whence;
  214.         lock.l_len = len;
  215.         
  216.         return(fcntl(fd, cmd, &lock));
  217. }

  219. //测试锁状态
  220. pid_t lock_test(int fd, int type, off_t offset, int whence, off_t len)
  221. {
  222.         struct flock lock;
  223.         
  224.         lock.l_type = type;
  225.         lock.l_start = offset;
  226.         lock.l_whence = whence;
  227.         lock.l_len = len;
  228.         
  229.         int ret;
  230.         ret = fcntl(fd, F_GETLK, &lock);
  231.         if(ret < 0)
  232.         {
  233.                 printf("fcntl F_GETLK err!\n");
  234.         }
  235.         
  236.         if(lock.l_type == F_UNLCK)
  237.         {
  238.                 printf("排斥锁不存在：则将l_type设置为F_UNLCK!该区域可能有锁但不排斥新锁，也可能没有锁!\n");
  239.                 return 0;
  240.         }
  241.                 
  242.         return(lock.l_pid);
  243. }


  246. /*
  247. 对一个文件描述符关闭一个文件状态标志
  248. 如：clr_fl(STDOUT_FILENO, O_SYNC); 关闭标准输出文件的同步写标志
  249. */
  250. void clr_fl(int fd, int flags)
  251. {
  252.         int val;
  253.         int ret;
  254.         //val = fcntl(fd, F_GETFL, 0);
  255.         val = fcntl(fd, F_GETFL);
  256.         if(val < 0)
  257.         {
  258.                 printf("fcntl F_GETFL err!\n");    
  259.                 return;
  260.         }
  261.     val &= ~flags; /* turn flags off */

  263.         ret = fcntl(fd, F_SETFL, val);
  264.         if(val < 0)
  265.         {
  266.                 printf("fcntl F_SETFL err!\n");    
  267.                 return;
  268.         }
  269.     return;
  270. }



  274. /*
  275. 对一个文件描述符打开一个文件状态标志
  276. 如：set_fl(STDOUT_FILENO, O_SYNC); 打开标准输出文件的同步写标志
  277. */
  278. void set_fl(int fd, int flags)
  279. {
  280.         int val;
  281.         int ret;
  282.         //val = fcntl(fd, F_GETFL, 0);
  283.         val = fcntl(fd, F_GETFL);
  284.         if(val < 0)
  285.         {
  286.                 printf("fcntl F_GETFL err!\n");    
  287.                 return;
  288.         }
  289.         val |= flags;
  290.         
  291.         ret = fcntl(fd, F_SETFL, val);
  292.         if(val < 0)
  293.         {
  294.                 printf("fcntl F_SETFL err!\n");    
  295.                 return;
  296.         }
  297.         return;
  298. }

阅读(614) | 评论(0) | 转发(0) |
0

上一篇：fflush函数

下一篇：fork，vfork函数

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6