sem.c

777

1. 
   
2. 1 /*
   
3.   2  * linux/ipc/sem.c
   
4.   3  * Copyright (C) 1992 Krishna Balasubramanian
   
5.   4  * Copyright (C) 1995 Eric Schenk, Bruno Haible
   
6.   5  *
   
7.   6  * IMPLEMENTATION NOTES ON CODE REWRITE (Eric Schenk, January 1995):
   
8.   7  * This code underwent a massive rewrite in order to solve some problems
   
9.   8  * with the original code. In particular the original code failed to
   
10.   9  * wake up processes that were waiting for semval to go to 0 if the
    
11. 10  * value went to 0 and was then incremented rapidly enough. In solving
    
12. 11  * this problem I have also modified the implementation so that it
    
13. 12  * processes pending operations in a FIFO manner, thus give a guarantee
    
14. 13  * that processes waiting for a lock on the semaphore won't starve
    
15. 14  * unless another locking process fails to unlock.
    
16. 15  * In addition the following two changes in behavior have been introduced:
    
17. 16  * - The original implementation of semop returned the value
    
18. 17  *   last semaphore element examined on success. This does not
    
19. 18  *   match the manual page specifications, and effectively
    
20. 19  *   allows the user to read the semaphore even if they do not
    
21. 20  *   have read permissions. The implementation now returns 0
    
22. 21  *   on success as stated in the manual page.
    
23. 22  * - There is some confusion over whether the set of undo adjustments
    
24. 23  *   to be performed at exit should be done in an atomic manner.
    
25. 24  *   That is, if we are attempting to decrement the semval should we queue
    
26. 25  *   up and wait until we can do so legally?
    
27. 26  *   The original implementation attempted to do this.
    
28. 27  *   The current implementation does not do so. This is because I don't
    
29. 28  *   think it is the right thing (TM) to do, and because I couldn't
    
30. 29  *   see a clean way to get the old behavior with the new design.
    
31. 30  *   The POSIX standard and SVID should be consulted to determine
    
32. 31  *   what behavior is mandated.
    
33. 32  *
    
34. 33  * Further notes on refinement (Christoph Rohland, December 1998):
    
35. 34  * - The POSIX standard says, that the undo adjustments simply should
    
36. 35  *   redo. So the current implementation is o.K.
    
37. 36  * - The previous code had two flaws:
    
38. 37  *   1) It actively gave the semaphore to the next waiting process
    
39. 38  *      sleeping on the semaphore. Since this process did not have the
    
40. 39  *      cpu this led to many unnecessary context switches and bad
    
41. 40  *      performance. Now we only check which process should be able to
    
42. 41  *      get the semaphore and if this process wants to reduce some
    
43. 42  *      semaphore value we simply wake it up without doing the
    
44. 43  *      operation. So it has to try to get it later. Thus e.g. the
    
45. 44  *      running process may reacquire the semaphore during the current
    
46. 45  *      time slice. If it only waits for zero or increases the semaphore,
    
47. 46  *      we do the operation in advance and wake it up.
    
48. 47  *   2) It did not wake up all zero waiting processes. We try to do
    
49. 48  *      better but only get the semops right which only wait for zero or
    
50. 49  *      increase. If there are decrement operations in the operations
    
51. 50  *      array we do the same as before.
    
52. 51  *
    
53. 52  * /proc/sysvipc/sem support (c) 1999 Dragos Acostachioaie <dragos@iname.com>
    
54. 53  *
    
55. 54  * SMP-threaded, sysctl's added
    
56. 55  * (c) 1999 Manfred Spraul <manfreds@colorfullife.com>
    
57. 56  * Enforced range limit on SEM_UNDO
    
58. 57  * (c) 2001 Red Hat Inc <alan@redhat.com>
    
59. 58  */
    
60. 59
    
61. 60 #include <linux/config.h>
    
62. 61 #include <linux/slab.h>
    
63. 62 #include <linux/spinlock.h>
    
64. 63 #include <linux/init.h>
    
65. 64 #include <linux/proc_fs.h>
    
66. 65 #include <asm/uaccess.h>
    
67. 66 #include "util.h"
    
68. 67
    
69. 68
    
70. 69 #define sem_lock(id)    ((struct sem_array*)ipc_lock(&sem_ids,id))
    
71. 70 #define sem_unlock(id)  ipc_unlock(&sem_ids,id)
    
72. 71 #define sem_rmid(id)    ((struct sem_array*)ipc_rmid(&sem_ids,id))
    
73. 72 #define sem_checkid(sma, semid) \
    
74. 73         ipc_checkid(&sem_ids,&sma->sem_perm,semid)
    
75. 74 #define sem_buildid(id, seq) \
    
76. 75         ipc_buildid(&sem_ids, id, seq)
    
77. 76 static struct ipc_ids sem_ids;
    
78. 77
    
79. 78 static int newary (key_t, int, int);
    
80. 79 static void freeary (int id);
    
81. 80 #ifdef CONFIG_PROC_FS
    
82. 81 static int sysvipc_sem_read_proc(char *buffer, char **start, off_t offset, int length, int *eof, void *data);
    
83. 82 #endif
    
84. 83
    
85. 84 #define SEMMSL_FAST     256 /* 512 bytes on stack */
    
86. 85 #define SEMOPM_FAST     64  /* ~ 372 bytes on stack */
    
87. 86
    
88. 87 /*
    
89. 88  * linked list protection:
    
90. 89  *      sem_undo.id_next,
    
91. 90  *      sem_array.sem_pending{,last},
    
92. 91  *      sem_array.sem_undo: sem_lock() for read/write
    
93. 92  *      sem_undo.proc_next: only "current" is allowed to read/write that field.
    
94. 93  *      
    
95. 94  */
    
96. 95
    
97. 96 int sem_ctls[4] = {SEMMSL, SEMMNS, SEMOPM, SEMMNI};
    
98. 97 #define sc_semmsl       (sem_ctls[0])
    
99. 98 #define sc_semmns       (sem_ctls[1])
    
100. 99 #define sc_semopm       (sem_ctls[2])
     
101. 100 #define sc_semmni       (sem_ctls[3])
     
102. 101
     
103. 102 static int used_sems;
     
104. 103
     
105. 104 void __init sem_init (void)
     
106. 105 {
     
107. 106         used_sems = 0;
     
108. 107         ipc_init_ids(&sem_ids,sc_semmni);
     
109. 108
     
110. 109 #ifdef CONFIG_PROC_FS
     
111. 110         create_proc_read_entry("sysvipc/sem", 0, 0, sysvipc_sem_read_proc, NULL);
     
112. 111 #endif
     
113. 112 }
     
114. 113
     
115. 114 static int newary (key_t key, int nsems, int semflg)
     
116. 115

复制代码