2 * Server-side change notification management
4 * Copyright (C) 1998 Alexandre Julliard
5 * Copyright (C) 2006 Mike McCormack
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
31 #include <sys/types.h>
35 #ifdef HAVE_SYS_ERRNO_H
36 #include <sys/errno.h>
40 #define WIN32_NO_STATUS
54 #define DN_ACCESS 0x00000001 /* File accessed */
55 #define DN_MODIFY 0x00000002 /* File modified */
56 #define DN_CREATE 0x00000004 /* File created */
57 #define DN_DELETE 0x00000008 /* File removed */
58 #define DN_RENAME 0x00000010 /* File renamed */
59 #define DN_ATTRIB 0x00000020 /* File changed attibutes */
60 #define DN_MULTISHOT 0x80000000 /* Don't remove notifier */
66 #if defined(__linux__) && defined(__i386__)
68 #define SYS_inotify_init 291
69 #define SYS_inotify_add_watch 292
70 #define SYS_inotify_rm_watch 293
72 struct inotify_event
{
80 #define IN_ACCESS 0x00000001
81 #define IN_MODIFY 0x00000002
82 #define IN_ATTRIB 0x00000004
83 #define IN_CLOSE_WRITE 0x00000008
84 #define IN_CLOSE_NOWRITE 0x00000010
85 #define IN_OPEN 0x00000020
86 #define IN_MOVED_FROM 0x00000040
87 #define IN_MOVED_TO 0x00000080
88 #define IN_CREATE 0x00000100
89 #define IN_DELETE 0x00000200
90 #define IN_DELETE_SELF 0x00000400
92 static inline int inotify_init( void )
95 __asm__
__volatile__( "int $0x80"
97 : "0" (SYS_inotify_init
));
98 if (ret
<0) { errno
= -ret
; ret
= -1; }
102 static inline int inotify_add_watch( int fd
, const char *name
, unsigned int mask
)
105 __asm__
__volatile__( "pushl %%ebx;\n\t"
109 : "=a" (ret
) : "0" (SYS_inotify_add_watch
),
110 "r" (fd
), "c" (name
), "d" (mask
) );
111 if (ret
<0) { errno
= -ret
; ret
= -1; }
115 static inline int inotify_remove_watch( int fd
, int wd
)
118 __asm__
__volatile__( "pushl %%ebx;\n\t"
122 : "=a" (ret
) : "0" (SYS_inotify_rm_watch
),
123 "r" (fd
), "c" (wd
) );
124 if (ret
<0) { errno
= -ret
; ret
= -1; }
134 static void free_inode( struct inode
*inode
);
136 static struct fd
*inotify_fd
;
138 struct change_record
{
147 struct object obj
; /* object header */
148 struct fd
*fd
; /* file descriptor to the directory */
149 struct list entry
; /* entry in global change notifications list */
151 unsigned int filter
; /* notification filter */
152 int notified
; /* SIGIO counter */
153 int want_data
; /* return change data */
154 long signaled
; /* the file changed */
155 int subtree
; /* do we want to watch subdirectories? */
156 struct list change_q
; /* change readers */
157 struct list change_records
; /* data for the change */
158 struct list in_entry
; /* entry in the inode dirs list */
159 struct inode
*inode
; /* inode of the associated directory */
162 static struct fd
*dir_get_fd( struct object
*obj
);
163 static unsigned int dir_map_access( struct object
*obj
, unsigned int access
);
164 static void dir_dump( struct object
*obj
, int verbose
);
165 static void dir_destroy( struct object
*obj
);
166 static int dir_signaled( struct object
*obj
, struct thread
*thread
);
168 static const struct object_ops dir_ops
=
170 sizeof(struct dir
), /* size */
172 add_queue
, /* add_queue */
173 remove_queue
, /* remove_queue */
174 dir_signaled
, /* signaled */
175 no_satisfied
, /* satisfied */
176 no_signal
, /* signal */
177 dir_get_fd
, /* get_fd */
178 dir_map_access
, /* map_access */
179 no_lookup_name
, /* lookup_name */
180 no_open_file
, /* open_file */
181 fd_close_handle
, /* close_handle */
182 dir_destroy
/* destroy */
185 static int dir_get_poll_events( struct fd
*fd
);
186 static enum server_fd_type
dir_get_info( struct fd
*fd
, int *flags
);
187 static void dir_cancel_async( struct fd
*fd
);
189 static const struct fd_ops dir_fd_ops
=
191 dir_get_poll_events
, /* get_poll_events */
192 default_poll_event
, /* poll_event */
193 no_flush
, /* flush */
194 dir_get_info
, /* get_file_info */
195 default_fd_queue_async
, /* queue_async */
196 dir_cancel_async
/* cancel_async */
199 static struct list change_list
= LIST_INIT(change_list
);
201 static void dnotify_adjust_changes( struct dir
*dir
)
203 #if defined(F_SETSIG) && defined(F_NOTIFY)
204 int fd
= get_unix_fd( dir
->fd
);
205 unsigned int filter
= dir
->filter
;
207 if ( 0 > fcntl( fd
, F_SETSIG
, SIGIO
) )
211 if (filter
& FILE_NOTIFY_CHANGE_FILE_NAME
)
212 val
|= DN_RENAME
| DN_DELETE
| DN_CREATE
;
213 if (filter
& FILE_NOTIFY_CHANGE_DIR_NAME
)
214 val
|= DN_RENAME
| DN_DELETE
| DN_CREATE
;
215 if (filter
& FILE_NOTIFY_CHANGE_ATTRIBUTES
)
217 if (filter
& FILE_NOTIFY_CHANGE_SIZE
)
219 if (filter
& FILE_NOTIFY_CHANGE_LAST_WRITE
)
221 if (filter
& FILE_NOTIFY_CHANGE_LAST_ACCESS
)
223 if (filter
& FILE_NOTIFY_CHANGE_CREATION
)
225 if (filter
& FILE_NOTIFY_CHANGE_SECURITY
)
227 fcntl( fd
, F_NOTIFY
, val
);
231 /* insert change in the global list */
232 static inline void insert_change( struct dir
*dir
)
236 sigemptyset( &sigset
);
237 sigaddset( &sigset
, SIGIO
);
238 sigprocmask( SIG_BLOCK
, &sigset
, NULL
);
239 list_add_head( &change_list
, &dir
->entry
);
240 sigprocmask( SIG_UNBLOCK
, &sigset
, NULL
);
243 /* remove change from the global list */
244 static inline void remove_change( struct dir
*dir
)
248 sigemptyset( &sigset
);
249 sigaddset( &sigset
, SIGIO
);
250 sigprocmask( SIG_BLOCK
, &sigset
, NULL
);
251 list_remove( &dir
->entry
);
252 sigprocmask( SIG_UNBLOCK
, &sigset
, NULL
);
255 static void dir_dump( struct object
*obj
, int verbose
)
257 struct dir
*dir
= (struct dir
*)obj
;
258 assert( obj
->ops
== &dir_ops
);
259 fprintf( stderr
, "Dirfile fd=%p event=%p filter=%08x\n",
260 dir
->fd
, dir
->event
, dir
->filter
);
263 static int dir_signaled( struct object
*obj
, struct thread
*thread
)
265 struct dir
*dir
= (struct dir
*)obj
;
266 assert (obj
->ops
== &dir_ops
);
267 return (dir
->event
== NULL
) && dir
->signaled
;
270 /* enter here directly from SIGIO signal handler */
271 void do_change_notify( int unix_fd
)
275 /* FIXME: this is O(n) ... probably can be improved */
276 LIST_FOR_EACH_ENTRY( dir
, &change_list
, struct dir
, entry
)
278 if (get_unix_fd( dir
->fd
) != unix_fd
) continue;
279 interlocked_xchg_add( &dir
->notified
, 1 );
284 static void dir_signal_changed( struct dir
*dir
)
286 if (!dir
->event
) wake_up( &dir
->obj
, 0 );
289 /* SIGIO callback, called synchronously with the poll loop */
290 void sigio_callback(void)
294 LIST_FOR_EACH_ENTRY( dir
, &change_list
, struct dir
, entry
)
296 long count
= interlocked_xchg( &dir
->notified
, 0 );
299 dir
->signaled
+= count
;
300 if (dir
->signaled
== count
) /* was it 0? */
301 dir_signal_changed( dir
);
306 static struct fd
*dir_get_fd( struct object
*obj
)
308 struct dir
*dir
= (struct dir
*)obj
;
309 assert( obj
->ops
== &dir_ops
);
310 return (struct fd
*)grab_object( dir
->fd
);
313 static unsigned int dir_map_access( struct object
*obj
, unsigned int access
)
315 if (access
& GENERIC_READ
) access
|= FILE_GENERIC_READ
;
316 if (access
& GENERIC_WRITE
) access
|= FILE_GENERIC_WRITE
;
317 if (access
& GENERIC_EXECUTE
) access
|= FILE_GENERIC_EXECUTE
;
318 if (access
& GENERIC_ALL
) access
|= FILE_ALL_ACCESS
;
319 return access
& ~(GENERIC_READ
| GENERIC_WRITE
| GENERIC_EXECUTE
| GENERIC_ALL
);
322 static struct change_record
*get_first_change_record( struct dir
*dir
)
324 struct list
*ptr
= list_head( &dir
->change_records
);
325 if (!ptr
) return NULL
;
327 return LIST_ENTRY( ptr
, struct change_record
, entry
);
330 static void dir_destroy( struct object
*obj
)
332 struct change_record
*record
;
333 struct dir
*dir
= (struct dir
*)obj
;
334 assert (obj
->ops
== &dir_ops
);
337 remove_change( dir
);
341 list_remove( &dir
->in_entry
);
342 free_inode( dir
->inode
);
345 async_terminate_queue( &dir
->change_q
, STATUS_CANCELLED
);
346 while ((record
= get_first_change_record( dir
))) free( record
);
348 if (dir
->event
) release_object( dir
->event
);
349 release_object( dir
->fd
);
351 if (inotify_fd
&& list_empty( &change_list
))
353 release_object( inotify_fd
);
359 get_dir_obj( struct process
*process
, obj_handle_t handle
, unsigned int access
)
361 return (struct dir
*)get_handle_obj( process
, handle
, access
, &dir_ops
);
364 static int dir_get_poll_events( struct fd
*fd
)
369 static enum server_fd_type
dir_get_info( struct fd
*fd
, int *flags
)
375 static void dir_cancel_async( struct fd
*fd
)
377 struct dir
*dir
= (struct dir
*) get_fd_user( fd
);
378 async_terminate_queue( &dir
->change_q
, STATUS_CANCELLED
);
387 struct list ch_entry
; /* entry in the children list */
388 struct list children
; /* children of this inode */
389 struct inode
*parent
; /* parent of this inode */
390 struct list dirs
; /* directory handles watching this inode */
391 struct list ino_entry
; /* entry in the inode hash */
392 struct list wd_entry
; /* entry in the watch descriptor hash */
393 dev_t dev
; /* device number */
394 ino_t ino
; /* device's inode number */
395 int wd
; /* inotify's watch descriptor */
396 char *name
; /* basename name of the inode */
399 struct list inode_hash
[ HASH_SIZE
];
400 struct list wd_hash
[ HASH_SIZE
];
402 static int inotify_add_dir( char *path
, unsigned int filter
);
404 static struct inode
*inode_from_wd( int wd
)
406 struct list
*bucket
= &wd_hash
[ wd
% HASH_SIZE
];
409 LIST_FOR_EACH_ENTRY( inode
, bucket
, struct inode
, wd_entry
)
416 static inline struct list
*get_hash_list( dev_t dev
, ino_t ino
)
418 return &inode_hash
[ (ino
^ dev
) % HASH_SIZE
];
421 static struct inode
*find_inode( dev_t dev
, ino_t ino
)
423 struct list
*bucket
= get_hash_list( dev
, ino
);
426 LIST_FOR_EACH_ENTRY( inode
, bucket
, struct inode
, ino_entry
)
427 if (inode
->ino
== ino
&& inode
->dev
== dev
)
433 static struct inode
*create_inode( dev_t dev
, ino_t ino
)
437 inode
= malloc( sizeof *inode
);
440 list_init( &inode
->children
);
441 list_init( &inode
->dirs
);
445 inode
->parent
= NULL
;
447 list_add_tail( get_hash_list( dev
, ino
), &inode
->ino_entry
);
452 static struct inode
*get_inode( dev_t dev
, ino_t ino
)
456 inode
= find_inode( dev
, ino
);
459 return create_inode( dev
, ino
);
462 static void inode_set_wd( struct inode
*inode
, int wd
)
465 list_remove( &inode
->wd_entry
);
467 list_add_tail( &wd_hash
[ wd
% HASH_SIZE
], &inode
->wd_entry
);
470 static void inode_set_name( struct inode
*inode
, const char *name
)
473 inode
->name
= name
? strdup( name
) : NULL
;
476 static void free_inode( struct inode
*inode
)
478 int subtree
= 0, watches
= 0;
481 LIST_FOR_EACH_ENTRY( dir
, &inode
->dirs
, struct dir
, in_entry
)
483 subtree
|= dir
->subtree
;
487 if (!subtree
&& !inode
->parent
)
489 struct inode
*tmp
, *next
;
490 LIST_FOR_EACH_ENTRY_SAFE( tmp
, next
, &inode
->children
,
491 struct inode
, ch_entry
)
493 assert( tmp
!= inode
);
494 assert( tmp
->parent
== inode
);
503 list_remove( &inode
->ch_entry
);
507 inotify_remove_watch( get_unix_fd( inotify_fd
), inode
->wd
);
508 list_remove( &inode
->wd_entry
);
510 list_remove( &inode
->ino_entry
);
516 static struct inode
*inode_add( struct inode
*parent
,
517 dev_t dev
, ino_t ino
, const char *name
)
521 inode
= get_inode( dev
, ino
);
527 list_add_tail( &parent
->children
, &inode
->ch_entry
);
528 inode
->parent
= parent
;
529 assert( inode
!= parent
);
531 inode_set_name( inode
, name
);
536 static struct inode
*inode_from_name( struct inode
*inode
, const char *name
)
540 LIST_FOR_EACH_ENTRY( i
, &inode
->children
, struct inode
, ch_entry
)
541 if (i
->name
&& !strcmp( i
->name
, name
))
546 static int inotify_get_poll_events( struct fd
*fd
);
547 static void inotify_poll_event( struct fd
*fd
, int event
);
549 static const struct fd_ops inotify_fd_ops
=
551 inotify_get_poll_events
, /* get_poll_events */
552 inotify_poll_event
, /* poll_event */
553 no_flush
, /* flush */
554 no_get_file_info
, /* get_file_info */
555 default_fd_queue_async
, /* queue_async */
556 default_fd_cancel_async
, /* cancel_async */
559 static int inotify_get_poll_events( struct fd
*fd
)
564 static void inotify_do_change_notify( struct dir
*dir
, unsigned int action
,
565 const char *relpath
)
567 struct change_record
*record
;
569 assert( dir
->obj
.ops
== &dir_ops
);
573 size_t len
= strlen(relpath
);
574 record
= malloc( offsetof(struct change_record
, name
[len
]) );
578 record
->action
= action
;
579 memcpy( record
->name
, relpath
, len
);
582 list_add_tail( &dir
->change_records
, &record
->entry
);
585 if (!list_empty( &dir
->change_q
))
586 async_terminate_head( &dir
->change_q
, STATUS_ALERTED
);
589 static unsigned int filter_from_event( struct inotify_event
*ie
)
591 unsigned int filter
= 0;
593 if (ie
->mask
& (IN_MOVED_FROM
| IN_MOVED_TO
| IN_DELETE
| IN_CREATE
))
594 filter
|= FILE_NOTIFY_CHANGE_FILE_NAME
| FILE_NOTIFY_CHANGE_DIR_NAME
;
595 if (ie
->mask
& IN_MODIFY
)
596 filter
|= FILE_NOTIFY_CHANGE_SIZE
| FILE_NOTIFY_CHANGE_LAST_WRITE
;
597 if (ie
->mask
& IN_ATTRIB
)
598 filter
|= FILE_NOTIFY_CHANGE_ATTRIBUTES
| FILE_NOTIFY_CHANGE_SECURITY
;
599 if (ie
->mask
& IN_ACCESS
)
600 filter
|= FILE_NOTIFY_CHANGE_LAST_ACCESS
;
601 if (ie
->mask
& IN_CREATE
)
602 filter
|= FILE_NOTIFY_CHANGE_CREATION
;
607 /* scan up the parent directories for watches */
608 static unsigned int filter_from_inode( struct inode
*inode
, int is_parent
)
610 unsigned int filter
= 0;
613 /* combine filters from parents watching subtrees */
616 LIST_FOR_EACH_ENTRY( dir
, &inode
->dirs
, struct dir
, in_entry
)
617 if (dir
->subtree
|| !is_parent
)
618 filter
|= dir
->filter
;
620 inode
= inode
->parent
;
626 static char *inode_get_path( struct inode
*inode
, int sz
)
635 head
= list_head( &inode
->dirs
);
638 int unix_fd
= get_unix_fd( LIST_ENTRY( head
, struct dir
, in_entry
)->fd
);
639 path
= malloc ( 32 + sz
);
641 sprintf( path
, "/proc/self/fd/%u/", unix_fd
);
648 len
= strlen( inode
->name
);
649 path
= inode_get_path( inode
->parent
, sz
+ len
+ 1 );
653 strcat( path
, inode
->name
);
659 static int inode_check_dir( struct inode
*parent
, const char *name
)
667 path
= inode_get_path( parent
, strlen(name
) );
671 strcat( path
, name
);
673 r
= stat( path
, &st
);
676 if (!S_ISDIR(st
.st_mode
))
684 filter
= filter_from_inode( parent
, 1 );
688 inode
= inode_add( parent
, st
.st_dev
, st
.st_ino
, name
);
689 if (!inode
|| inode
->wd
!= -1)
692 wd
= inotify_add_dir( path
, filter
);
694 inode_set_wd( inode
, wd
);
703 static int prepend( char **path
, const char *segment
)
708 extra
= strlen( segment
) + 1;
711 int len
= strlen( *path
) + 1;
712 p
= realloc( *path
, len
+ extra
);
714 memmove( &p
[ extra
], p
, len
);
715 p
[ extra
- 1 ] = '/';
716 memcpy( p
, segment
, extra
- 1 );
722 memcpy( p
, segment
, extra
);
730 static void inotify_notify_all( struct inotify_event
*ie
)
732 unsigned int filter
, action
;
733 struct inode
*inode
, *i
;
737 inode
= inode_from_wd( ie
->wd
);
740 fprintf( stderr
, "no inode matches %d\n", ie
->wd
);
744 filter
= filter_from_event( ie
);
746 if (ie
->mask
& IN_CREATE
)
748 switch (inode_check_dir( inode
, ie
->name
))
751 filter
&= ~FILE_NOTIFY_CHANGE_FILE_NAME
;
754 filter
&= ~FILE_NOTIFY_CHANGE_DIR_NAME
;
758 /* Maybe the file disappeared before we could check it? */
760 action
= FILE_ACTION_ADDED
;
762 else if (ie
->mask
& IN_DELETE
)
763 action
= FILE_ACTION_REMOVED
;
765 action
= FILE_ACTION_MODIFIED
;
768 * Work our way up the inode hierarchy
769 * extending the relative path as we go
770 * and notifying all recursive watches.
772 if (!prepend( &path
, ie
->name
))
775 for (i
= inode
; i
; i
= i
->parent
)
777 LIST_FOR_EACH_ENTRY( dir
, &i
->dirs
, struct dir
, in_entry
)
778 if ((filter
& dir
->filter
) && (i
==inode
|| dir
->subtree
))
779 inotify_do_change_notify( dir
, action
, path
);
781 if (!i
->name
|| !prepend( &path
, i
->name
))
787 if (ie
->mask
& IN_DELETE
)
789 i
= inode_from_name( inode
, ie
->name
);
795 static void inotify_poll_event( struct fd
*fd
, int event
)
799 struct inotify_event
*ie
;
801 unix_fd
= get_unix_fd( fd
);
802 r
= read( unix_fd
, buffer
, sizeof buffer
);
805 fprintf(stderr
,"inotify_poll_event(): inotify read failed!\n");
809 for( ofs
= 0; ofs
< r
- offsetof(struct inotify_event
, name
); )
811 ie
= (struct inotify_event
*) &buffer
[ofs
];
814 ofs
+= offsetof( struct inotify_event
, name
[ie
->len
] );
816 inotify_notify_all( ie
);
820 static inline struct fd
*create_inotify_fd( void )
824 unix_fd
= inotify_init();
827 return create_anonymous_fd( &inotify_fd_ops
, unix_fd
, NULL
);
830 static int map_flags( unsigned int filter
)
834 /* always watch these so we can track subdirectories in recursive watches */
835 mask
= (IN_MOVED_FROM
| IN_MOVED_TO
| IN_DELETE
| IN_CREATE
| IN_DELETE_SELF
);
837 if (filter
& FILE_NOTIFY_CHANGE_ATTRIBUTES
)
839 if (filter
& FILE_NOTIFY_CHANGE_SIZE
)
841 if (filter
& FILE_NOTIFY_CHANGE_LAST_WRITE
)
843 if (filter
& FILE_NOTIFY_CHANGE_LAST_ACCESS
)
845 if (filter
& FILE_NOTIFY_CHANGE_SECURITY
)
851 static int inotify_add_dir( char *path
, unsigned int filter
)
853 int wd
= inotify_add_watch( get_unix_fd( inotify_fd
),
854 path
, map_flags( filter
) );
856 set_fd_events( inotify_fd
, POLLIN
);
860 static int init_inotify( void )
867 inotify_fd
= create_inotify_fd();
871 for (i
=0; i
<HASH_SIZE
; i
++)
873 list_init( &inode_hash
[i
] );
874 list_init( &wd_hash
[i
] );
880 static int inotify_adjust_changes( struct dir
*dir
)
891 unix_fd
= get_unix_fd( dir
->fd
);
896 /* check if this fd is already being watched */
897 if (-1 == fstat( unix_fd
, &st
))
900 inode
= get_inode( st
.st_dev
, st
.st_ino
);
902 inode
= create_inode( st
.st_dev
, st
.st_ino
);
905 list_add_tail( &inode
->dirs
, &dir
->in_entry
);
909 filter
= filter_from_inode( inode
, 0 );
911 sprintf( path
, "/proc/self/fd/%u", unix_fd
);
912 wd
= inotify_add_dir( path
, filter
);
913 if (wd
== -1) return 0;
915 inode_set_wd( inode
, wd
);
920 static char *get_basename( const char *link
)
922 char *buffer
, *name
= NULL
;
927 buffer
= malloc( n
);
928 if (!buffer
) return NULL
;
930 r
= readlink( link
, buffer
, n
);
945 while (r
> 0 && name
[ r
- 1 ] == '/' )
949 name
= strrchr( name
, '/' );
951 name
= strdup( &name
[1] );
958 static int dir_add_to_existing_notify( struct dir
*dir
)
960 struct inode
*inode
, *parent
;
961 unsigned int filter
= 0;
962 struct stat st
, st_new
;
963 char link
[35], *name
;
969 unix_fd
= get_unix_fd( dir
->fd
);
971 /* check if it's in the list of inodes we want to watch */
972 if (-1 == fstat( unix_fd
, &st_new
))
974 inode
= find_inode( st_new
.st_dev
, st_new
.st_ino
);
978 /* lookup the parent */
979 sprintf( link
, "/proc/self/fd/%u/..", unix_fd
);
980 if (-1 == stat( link
, &st
))
984 * If there's no parent, stop. We could keep going adding
985 * ../ to the path until we hit the root of the tree or
986 * find a recursively watched ancestor.
987 * Assume it's too expensive to search up the tree for now.
989 parent
= find_inode( st
.st_dev
, st
.st_ino
);
993 if (parent
->wd
== -1)
996 filter
= filter_from_inode( parent
, 1 );
1000 sprintf( link
, "/proc/self/fd/%u", unix_fd
);
1001 name
= get_basename( link
);
1004 inode
= inode_add( parent
, st_new
.st_dev
, st_new
.st_ino
, name
);
1009 /* Couldn't find this inode at the start of the function, must be new */
1010 assert( inode
->wd
== -1 );
1012 wd
= inotify_add_dir( link
, filter
);
1014 inode_set_wd( inode
, wd
);
1021 static int init_inotify( void )
1026 static int inotify_adjust_changes( struct dir
*dir
)
1031 static void free_inode( struct inode
*inode
)
1036 static int dir_add_to_existing_notify( struct dir
*dir
)
1041 #endif /* USE_INOTIFY */
1043 struct object
*create_dir_obj( struct fd
*fd
)
1047 dir
= alloc_object( &dir_ops
);
1051 list_init( &dir
->change_q
);
1052 list_init( &dir
->change_records
);
1061 set_fd_user( fd
, &dir_fd_ops
, &dir
->obj
);
1063 dir_add_to_existing_notify( dir
);
1068 /* enable change notifications for a directory */
1069 DECL_HANDLER(read_directory_changes
)
1071 struct event
*event
= NULL
;
1076 set_error(STATUS_INVALID_PARAMETER
);
1080 dir
= get_dir_obj( current
->process
, req
->handle
, 0 );
1084 /* possibly send changes through an event flag */
1085 if (req
->async
.event
&&
1086 !(event
= get_event_obj( current
->process
, req
->async
.event
, EVENT_MODIFY_STATE
)))
1089 /* discard the current data, and move onto the next event */
1090 if (dir
->event
) release_object( dir
->event
);
1093 /* requests don't timeout */
1094 if (!create_async( current
, NULL
, &dir
->change_q
, &req
->async
)) goto end
;
1096 /* assign it once */
1100 insert_change( dir
);
1101 dir
->filter
= req
->filter
;
1102 dir
->subtree
= req
->subtree
;
1103 dir
->want_data
= req
->want_data
;
1106 /* remove any notifications */
1107 if (dir
->signaled
>0)
1110 /* if there's already a change in the queue, send it */
1111 if (!list_empty( &dir
->change_q
) &&
1112 !list_empty( &dir
->change_records
))
1113 async_terminate_head( &dir
->change_q
, STATUS_ALERTED
);
1115 /* setup the real notification */
1116 if (!inotify_adjust_changes( dir
))
1117 dnotify_adjust_changes( dir
);
1119 set_error(STATUS_PENDING
);
1122 release_object( dir
);
1125 DECL_HANDLER(read_change
)
1127 struct change_record
*record
;
1130 dir
= get_dir_obj( current
->process
, req
->handle
, 0 );
1134 if ((record
= get_first_change_record( dir
)) != NULL
)
1136 reply
->action
= record
->action
;
1137 set_reply_data( record
->name
, record
->len
);
1141 set_error( STATUS_NO_DATA_DETECTED
);
1145 dir_signal_changed( dir
);
1147 release_object( dir
);