Use 'dumb quotes' rather than `really dumb quotes'
[platform/upstream/glib.git] / gio / kqueue / kqueue-thread.c
1 /*******************************************************************************
2   Copyright (c) 2011, 2012 Dmitry Matveev <me@dmitrymatveev.co.uk>
3
4   Permission is hereby granted, free of charge, to any person obtaining a copy
5   of this software and associated documentation files (the "Software"), to deal
6   in the Software without restriction, including without limitation the rights
7   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8   copies of the Software, and to permit persons to whom the Software is
9   furnished to do so, subject to the following conditions:
10
11   The above copyright notice and this permission notice shall be included in
12   all copies or substantial portions of the Software.
13
14   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20   THE SOFTWARE.
21 *******************************************************************************/
22
23 #include "config.h"
24 #include <sys/types.h>
25 #include <sys/event.h>
26 #include <sys/time.h>
27 #include <unistd.h>
28 #include <errno.h>
29 #include <glib.h>
30
31 #include "kqueue-thread.h"
32 #include "kqueue-sub.h"
33 #include "kqueue-utils.h"
34
35 static gboolean kt_debug_enabled = FALSE;
36 #define KT_W if (kt_debug_enabled) g_warning
37
38 static GQueue pick_up_fds_queue = G_QUEUE_INIT;
39 G_LOCK_DEFINE_STATIC (pick_up_lock);
40
41 static GSList *remove_fds_list = NULL;
42 G_LOCK_DEFINE_STATIC (remove_lock);
43
44 /* GIO does not have analogues for NOTE_LINK and(?) NOTE_REVOKE, so
45  * we do not ask kqueue() to watch for these events for now. */
46 const uint32_t KQUEUE_VNODE_FLAGS =
47   NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME;
48
49 extern int get_kqueue_descriptor(void);
50
51 /**
52  * _kqueue_thread_collect_fds:
53  * @events: a #kevents - the list of events to monitor. Will be extended
54  *     with new items.
55  *
56  * Picks up new file descriptors for monitoring from a global queue.
57  *
58  * To add new items to the list, use _kqueue_thread_push_fd().
59  **/
60 static void
61 _kqueue_thread_collect_fds (kevents *events)
62 {
63   g_assert (events != NULL);
64   gint length = 0;
65
66   G_LOCK (pick_up_lock);
67   if ((length = g_queue_get_length (&pick_up_fds_queue)) != 0)
68     {
69       gpointer fdp = NULL;
70       kevents_extend_sz (events, length);
71
72       while ((fdp = g_queue_pop_head (&pick_up_fds_queue)) != NULL)
73         {
74           struct kevent *pevent = &events->memory[events->kq_size++];
75           EV_SET (pevent,
76                   GPOINTER_TO_INT (fdp),
77                   EVFILT_VNODE,
78                   EV_ADD | EV_ENABLE | EV_ONESHOT,
79                   KQUEUE_VNODE_FLAGS,
80                   0,
81                   0);
82         }
83     }
84   G_UNLOCK (pick_up_lock);
85 }
86
87
88 /**
89  * _kqueue_thread_cleanup_fds:
90  * @events: a #kevents -- list of events to monitor. Cancelled
91  *     subscriptions will be removed from it, and its size
92  *     probably will be reduced.
93  *
94  * Removes file descriptors from monitoring.
95  *
96  * This function will pick up file descriptors from a global list
97  * to cancel monitoring on them. The list will be freed then.
98  *
99  * To add new items to the list, use _kqueue_thread_remove_fd().
100  **/
101 static void
102 _kqueue_thread_cleanup_fds (kevents *events)
103 {
104   g_assert (events != NULL);
105
106   G_LOCK (remove_lock);
107   if (remove_fds_list)
108     {
109       size_t oldsize = events->kq_size;
110       int i, j;
111
112       for (i = 1, j = 1; i < oldsize; i++)
113         {
114           int fd = events->memory[i].ident;
115           GSList *elem = g_slist_find (remove_fds_list, GINT_TO_POINTER (fd));
116           if (elem == NULL)
117             {
118               if (i != j)
119                 events->memory[j] = events->memory[i];
120               ++j;
121             }
122           else if (close (fd) == -1)
123             KT_W ("Failed to close fd %d, error %d", fd, errno);
124         }
125
126       KT_W ("FD Clean up complete, kq_size now %d\n", j);
127       events->kq_size = j;
128       kevents_reduce (events);
129       g_slist_free (remove_fds_list);
130       remove_fds_list = NULL;
131     }
132   G_UNLOCK (remove_lock);
133 }
134
135
136 /**
137  * _kqueue_thread_drop_fd:
138  * @events: a #kevents -- list of events to monitor. Cancelled
139  *     subscriptions will be removed from it, and its size
140  *     probably will be reduced.
141  *
142  * Removes a concrete file descriptor from monitoring.
143  **/
144 static void
145 _kqueue_thread_drop_fd (kevents *events, int fd)
146 {
147   g_assert (events != NULL);
148
149   int i;
150   for (i = 1; i < events->kq_size; i++)
151     {
152       if (events->memory[i].ident == fd)
153         {
154           if (close (fd) == -1)
155             KT_W ("Failed to close fd %d, error %d", fd, errno);
156
157           events->memory[i] = events->memory[--events->kq_size];
158           return;
159         }
160     } 
161 }
162
163 /**
164  * _kqueue_thread_func:
165  * @arg: a pointer to int -- control file descriptor.
166  *
167  * The thread communicates with the outside world through a so-called
168  * command file descriptor. The thread reads control commands from it
169  * and writes the notifications into it.
170  *
171  * Control commands are single-byte characters:
172  * <itemizedlist>
173  * <listitem>
174  *   'A' - pick up new file descriptors to monitor
175  * </listitem>
176  * <listitem>
177  *   'R' - remove some descriptors from monitoring.
178  * </listitem>
179  * </itemizedlist>
180  *
181  * For details, see _kqueue_thread_collect_fds() and
182  * _kqueue_thread_cleanup_fds().
183  *
184  * Notifications, that thread writes into the command file descriptor,
185  * are represented with #kqueue_notification objects.
186  *
187  * Returns: %NULL
188  **/
189 void*
190 _kqueue_thread_func (void *arg)
191 {
192   int fd, kqueue_descriptor;
193   kevents waiting;
194
195   g_assert (arg != NULL);
196   kevents_init_sz (&waiting, 1);
197
198   fd = *(int *) arg;
199
200   kqueue_descriptor = get_kqueue_descriptor();
201   if (kqueue_descriptor == -1)
202     {
203       KT_W ("fatal: kqueue is not initialized!\n");
204       return NULL;
205     }
206
207   EV_SET (&waiting.memory[0],
208           fd,
209           EVFILT_READ,
210           EV_ADD | EV_ENABLE | EV_ONESHOT,
211           NOTE_LOWAT,
212           1,
213           0);
214   waiting.kq_size = 1;
215
216   for (;;)
217     {
218       /* TODO: Provide more items in the 'eventlist' to kqueue(2).
219        * Currently the backend takes notifications from the kernel one
220        * by one, i.e. there will be a lot of system calls and context
221        * switches when the application will monitor a lot of files with
222        * high filesystem activity on each. */
223      
224       struct kevent received;
225       KT_W ("Watching for %zi items", waiting.kq_size);
226       int ret = kevent (kqueue_descriptor, waiting.memory, waiting.kq_size, &received, 1, NULL);
227       int kevent_errno = errno;
228       KT_W ("Awoken.");
229
230       if (ret == -1)
231         {
232           KT_W ("kevent failed: %d", kevent_errno);
233           if (kevent_errno == EINTR)
234             continue;
235           else
236             return NULL;
237         }
238
239       if (received.ident == fd)
240         {
241           char c;
242             if (!_ku_read (fd, &c, 1))
243               {
244                 KT_W ("Failed to read command, error %d", errno);
245                 continue;
246               }
247           if (c == 'A')
248             _kqueue_thread_collect_fds (&waiting);
249           else if (c == 'R')
250             _kqueue_thread_cleanup_fds (&waiting);
251         }
252       else 
253         {
254           struct kqueue_notification kn;
255           kn.fd = received.ident;
256
257           if (received.flags & EV_ERROR)
258             {
259               kn.flags = NOTE_REVOKE;
260               _kqueue_thread_drop_fd (&waiting, received.ident);
261             }
262           else
263             kn.flags = (received.fflags & ~NOTE_REVOKE);
264
265           if (!_ku_write (fd, &kn, sizeof (struct kqueue_notification)))
266             KT_W ("Failed to write a kqueue notification, error %d", errno);
267         }
268     }
269   kevents_free (&waiting);
270   return NULL;
271 }
272
273
274 /**
275  * _kqueue_thread_push_fd:
276  * @fd: a file descriptor
277  *
278  * Puts a new file descriptor into the pick up list for monitroing.
279  *
280  * The kqueue thread will not start monitoring on it immediately, it
281  * should be bumped via its command file descriptor manually.
282  * See kqueue_thread() and _kqueue_thread_collect_fds() for details.
283  **/
284 void
285 _kqueue_thread_push_fd (int fd)
286 {
287   G_LOCK (pick_up_lock);
288   g_queue_push_tail (&pick_up_fds_queue, GINT_TO_POINTER (fd));
289   G_UNLOCK (pick_up_lock);
290 }
291
292
293 /**
294  * _kqueue_thread_remove_fd:
295  * @fd: a file descriptor
296  *
297  * Puts a new file descriptor into the remove list to cancel monitoring
298  * on it.
299  *
300  * The kqueue thread will not stop monitoring on it immediately, it
301  * should be bumped via its command file descriptor manually.
302  * See kqueue_thread() and _kqueue_thread_collect_fds() for details.
303  **/
304 void
305 _kqueue_thread_remove_fd (int fd)
306 {
307   G_LOCK (remove_lock);
308   remove_fds_list = g_slist_prepend (remove_fds_list, GINT_TO_POINTER (fd));
309   G_UNLOCK (remove_lock);
310 }