1 /* vi: set sw=4 ts=4: */
2 /*
3 * simple inotify daemon
4 * reports filesystem changes via userspace agent
5 *
6 * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
7 *
8 * Licensed under GPLv2, see file LICENSE in this source tree.
9 */
10
11 /*
12 * Use as follows:
13 * # inotifyd /user/space/agent dir/or/file/being/watched[:mask] ...
14 *
15 * When a filesystem event matching the specified mask is occurred on specified file (or directory)
16 * a userspace agent is spawned and given the following parameters:
17 * $1. actual event(s)
18 * $2. file (or directory) name
19 * $3. name of subfile (if any), in case of watching a directory
20 *
21 * E.g. inotifyd ./dev-watcher /dev:n
22 *
23 * ./dev-watcher can be, say:
24 * #!/bin/sh
25 * echo "We have new device in here! Hello, $3!"
26 *
27 * See below for mask names explanation.
28 */
29 //config:config INOTIFYD
30 //config: bool "inotifyd (3.6 kb)"
31 //config: default n # doesn't build on Knoppix 5
32 //config: help
33 //config: Simple inotify daemon. Reports filesystem changes. Requires
34 //config: kernel >= 2.6.13
35
36 //applet:IF_INOTIFYD(APPLET(inotifyd, BB_DIR_SBIN, BB_SUID_DROP))
37
38 //kbuild:lib-$(CONFIG_INOTIFYD) += inotifyd.o
39
40 //usage:#define inotifyd_trivial_usage
41 //usage: "PROG FILE1[:MASK]..."
42 //usage:#define inotifyd_full_usage "\n\n"
43 //usage: "Run PROG on filesystem changes."
44 //usage: "\nWhen a filesystem event matching MASK occurs on FILEn,"
45 //usage: "\nPROG ACTUAL_EVENTS FILEn [SUBFILE] is run."
46 //usage: "\nIf PROG is -, events are sent to stdout."
47 //usage: "\nEvents:"
48 //usage: "\n a File is accessed"
49 //usage: "\n c File is modified"
50 //usage: "\n e Metadata changed"
51 //usage: "\n w Writable file is closed"
52 //usage: "\n 0 Unwritable file is closed"
53 //usage: "\n r File is opened"
54 //usage: "\n D File is deleted"
55 //usage: "\n M File is moved"
56 //usage: "\n u Backing fs is unmounted"
57 //usage: "\n o Event queue overflowed"
58 //usage: "\n x File can't be watched anymore"
59 //usage: "\nIf watching a directory:"
60 //usage: "\n y Subfile is moved into dir"
61 //usage: "\n m Subfile is moved out of dir"
62 //usage: "\n n Subfile is created"
63 //usage: "\n d Subfile is deleted"
64 //usage: "\n"
65 //usage: "\ninotifyd waits for PROG to exit."
66 //usage: "\nWhen x event happens for all FILEs, inotifyd exits."
67
68 #include "libbb.h"
69 #include "common_bufsiz.h"
70 #include <sys/inotify.h>
71
72 static const char mask_names[] ALIGN1 =
73 "a" // 0x00000001 File was accessed
74 "c" // 0x00000002 File was modified
75 "e" // 0x00000004 Metadata changed
76 "w" // 0x00000008 Writable file was closed
77 "0" // 0x00000010 Unwritable file closed
78 "r" // 0x00000020 File was opened
79 "m" // 0x00000040 File was moved from X
80 "y" // 0x00000080 File was moved to Y
81 "n" // 0x00000100 Subfile was created
82 "d" // 0x00000200 Subfile was deleted
83 "D" // 0x00000400 Self was deleted
84 "M" // 0x00000800 Self was moved
85 "\0" // 0x00001000 (unused)
86 // Kernel events, always reported:
87 "u" // 0x00002000 Backing fs was unmounted
88 "o" // 0x00004000 Event queued overflowed
89 "x" // 0x00008000 File is no longer watched (usually deleted)
90 ;
91 enum {
92 MASK_BITS = sizeof(mask_names) - 1
93 };
94
95 int inotifyd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
inotifyd_main(int argc,char ** argv)96 int inotifyd_main(int argc, char **argv)
97 {
98 int n;
99 unsigned mask;
100 struct pollfd pfd;
101 char **watches; // names of files being watched
102 const char *args[5];
103
104 // sanity check: agent and at least one watch must be given
105 if (!argv[1] || !argv[2])
106 bb_show_usage();
107
108 argv++;
109 // inotify_add_watch will number watched files
110 // starting from 1, thus watches[0] is unimportant,
111 // and 1st file name is watches[1].
112 watches = argv;
113 args[0] = *argv;
114 args[4] = NULL;
115 argc -= 2; // number of files we watch
116
117 // open inotify
118 pfd.fd = inotify_init();
119 if (pfd.fd < 0)
120 bb_simple_perror_msg_and_die("no kernel support");
121
122 // setup watches
123 while (*++argv) {
124 char *path = *argv;
125 char *masks = strchr(path, ':');
126
127 mask = 0x0fff; // assuming we want all non-kernel events
128 // if mask is specified ->
129 if (masks) {
130 *masks = '\0'; // split path and mask
131 // convert mask names to mask bitset
132 mask = 0;
133 while (*++masks) {
134 const char *found;
135 found = memchr(mask_names, *masks, MASK_BITS);
136 if (found)
137 mask |= (1 << (found - mask_names));
138 }
139 }
140 // add watch
141 n = inotify_add_watch(pfd.fd, path, mask);
142 if (n < 0)
143 bb_perror_msg_and_die("add watch (%s) failed", path);
144 //bb_error_msg("added %d [%s]:%4X", n, path, mask);
145 }
146
147 // setup signals
148 bb_signals(BB_FATAL_SIGS, record_signo);
149
150 // do watch
151 pfd.events = POLLIN;
152 while (1) {
153 int len;
154 void *buf;
155 struct inotify_event *ie;
156 again:
157 if (bb_got_signal)
158 break;
159 n = poll(&pfd, 1, -1);
160 // Signal interrupted us?
161 if (n < 0 && errno == EINTR)
162 goto again;
163 // Under Linux, above if() is not necessary.
164 // Non-fatal signals, e.g. SIGCHLD, when set to SIG_DFL,
165 // are not interrupting poll().
166 // Thus we can just break if n <= 0 (see below),
167 // because EINTR will happen only on SIGTERM et al.
168 // But this might be not true under other Unixes,
169 // and is generally way too subtle to depend on.
170 if (n <= 0) // strange error?
171 break;
172
173 // read out all pending events
174 // (NB: len must be int, not ssize_t or long!)
175 #define eventbuf bb_common_bufsiz1
176 setup_common_bufsiz();
177 xioctl(pfd.fd, FIONREAD, &len);
178 ie = buf = (len <= COMMON_BUFSIZE) ? eventbuf : xmalloc(len);
179 len = full_read(pfd.fd, buf, len);
180 // process events. N.B. events may vary in length
181 while (len > 0) {
182 int i;
183 // cache relevant events mask
184 unsigned m = ie->mask & ((1 << MASK_BITS) - 1);
185 if (m) {
186 char events[MASK_BITS + 1];
187 char *s = events;
188 for (i = 0; i < MASK_BITS; ++i, m >>= 1) {
189 if ((m & 1) && (mask_names[i] != '\0'))
190 *s++ = mask_names[i];
191 }
192 *s = '\0';
193 if (LONE_CHAR(args[0], '-')) {
194 /* "inotifyd - FILE": built-in echo */
195 printf(ie->len ? "%s\t%s\t%s\n" : "%s\t%s\n", events,
196 watches[ie->wd],
197 ie->name);
198 fflush(stdout);
199 } else {
200 // bb_error_msg("exec %s %08X\t%s\t%s\t%s", args[0],
201 // ie->mask, events, watches[ie->wd], ie->len ? ie->name : "");
202 args[1] = events;
203 args[2] = watches[ie->wd];
204 args[3] = ie->len ? ie->name : NULL;
205 spawn_and_wait((char **)args);
206 }
207 // we are done if all files got final x event
208 if (ie->mask & 0x8000) {
209 if (--argc <= 0)
210 goto done;
211 inotify_rm_watch(pfd.fd, ie->wd);
212 }
213 }
214 // next event
215 i = sizeof(struct inotify_event) + ie->len;
216 len -= i;
217 ie = (void*)((char*)ie + i);
218 }
219 if (eventbuf != buf)
220 free(buf);
221 } // while (1)
222 done:
223 return bb_got_signal;
224 }
225