server/change.c

   1 /*
   2  * Server-side change notification management
   3  *
   4  * Copyright (C) 1998 Alexandre Julliard
   5  * Copyright (C) 2006 Mike McCormack
   6  *
   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.
  11  *
  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.
  16  *
  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <fcntl.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <signal.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #include <limits.h>
  33 #include <dirent.h>
  34 #include <errno.h>
  35 #ifdef HAVE_SYS_ERRNO_H
  36 #include <sys/errno.h>
  37 #endif
  38
  39 #include "ntstatus.h"
  40 #define WIN32_NO_STATUS
  41 #include "windef.h"
  42
  43 #include "file.h"
  44 #include "handle.h"
  45 #include "thread.h"
  46 #include "request.h"
  47 #include "winternl.h"
  48
  49 /* dnotify support */
  50
  51 #ifdef linux
  52 #ifndef F_NOTIFY
  53 #define F_NOTIFY 1026
  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 */
  61 #endif
  62 #endif
  63
  64 /* inotify support */
  65
  66 #if defined(__linux__) && defined(__i386__)
  67
  68 #define SYS_inotify_init        291
  69 #define SYS_inotify_add_watch   292
  70 #define SYS_inotify_rm_watch    293
  71
  72 struct inotify_event {
  73     int           wd;
  74     unsigned int  mask;
  75     unsigned int  cookie;
  76     unsigned int  len;
  77     char          name[1];
  78 };
  79
  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
  91
  92 static inline int inotify_init( void )
  93 {
  94     int ret;
  95     __asm__ __volatile__( "int $0x80"
  96                           : "=a" (ret)
  97                           : "0" (SYS_inotify_init));
  98     if (ret<0) { errno = -ret; ret = -1; }
  99     return ret;
 100 }
 101
 102 static inline int inotify_add_watch( int fd, const char *name, unsigned int mask )
 103 {
 104     int ret;
 105     __asm__ __volatile__( "pushl %%ebx;\n\t"
 106                           "movl %2,%%ebx;\n\t"
 107                           "int $0x80;\n\t"
 108                           "popl %%ebx"
 109                           : "=a" (ret) : "0" (SYS_inotify_add_watch),
 110                             "r" (fd), "c" (name), "d" (mask) );
 111     if (ret<0) { errno = -ret; ret = -1; }
 112     return ret;
 113 }
 114
 115 static inline int inotify_remove_watch( int fd, int wd )
 116 {
 117     int ret;
 118     __asm__ __volatile__( "pushl %%ebx;\n\t"
 119                           "movl %2,%%ebx;\n\t"
 120                           "int $0x80;\n\t"
 121                           "popl %%ebx"
 122                           : "=a" (ret) : "0" (SYS_inotify_rm_watch),
 123                             "r" (fd), "c" (wd) );
 124     if (ret<0) { errno = -ret; ret = -1; }
 125     return ret;
 126 }
 127
 128 #define USE_INOTIFY
 129
 130 #endif
 131
 132 struct inode;
 133
 134 static void free_inode( struct inode *inode );
 135
 136 static struct fd *inotify_fd;
 137
 138 struct change_record {
 139     struct list entry;
 140     int action;
 141     int len;
 142     char name[1];
 143 };
 144
 145 struct dir
 146 {
 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 */
 150     struct event  *event;
 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     struct list    change_q; /* change readers */
 156     struct list    change_records;   /* data for the change */
 157     struct list    in_entry; /* entry in the inode dirs list */
 158     struct inode  *inode;    /* inode of the associated directory */
 159 };
 160
 161 static struct fd *dir_get_fd( struct object *obj );
 162 static unsigned int dir_map_access( struct object *obj, unsigned int access );
 163 static void dir_dump( struct object *obj, int verbose );
 164 static void dir_destroy( struct object *obj );
 165 static int dir_signaled( struct object *obj, struct thread *thread );
 166
 167 static const struct object_ops dir_ops =
 168 {
 169     sizeof(struct dir),       /* size */
 170     dir_dump,                 /* dump */
 171     add_queue,                /* add_queue */
 172     remove_queue,             /* remove_queue */
 173     dir_signaled,             /* signaled */
 174     no_satisfied,             /* satisfied */
 175     no_signal,                /* signal */
 176     dir_get_fd,               /* get_fd */
 177     dir_map_access,           /* map_access */
 178     no_lookup_name,           /* lookup_name */
 179     no_close_handle,          /* close_handle */
 180     dir_destroy               /* destroy */
 181 };
 182
 183 static int dir_get_poll_events( struct fd *fd );
 184 static int dir_get_info( struct fd *fd );
 185 static void dir_cancel_async( struct fd *fd );
 186
 187 static const struct fd_ops dir_fd_ops =
 188 {
 189     dir_get_poll_events,      /* get_poll_events */
 190     default_poll_event,       /* poll_event */
 191     no_flush,                 /* flush */
 192     dir_get_info,             /* get_file_info */
 193     default_fd_queue_async,   /* queue_async */
 194     dir_cancel_async          /* cancel_async */
 195 };
 196
 197 static struct list change_list = LIST_INIT(change_list);
 198
 199 static void dnotify_adjust_changes( struct dir *dir )
 200 {
 201 #if defined(F_SETSIG) && defined(F_NOTIFY)
 202     int fd = get_unix_fd( dir->fd );
 203     unsigned int filter = dir->filter;
 204     unsigned int val;
 205     if ( 0 > fcntl( fd, F_SETSIG, SIGIO) )
 206         return;
 207
 208     val = DN_MULTISHOT;
 209     if (filter & FILE_NOTIFY_CHANGE_FILE_NAME)
 210         val |= DN_RENAME | DN_DELETE | DN_CREATE;
 211     if (filter & FILE_NOTIFY_CHANGE_DIR_NAME)
 212         val |= DN_RENAME | DN_DELETE | DN_CREATE;
 213     if (filter & FILE_NOTIFY_CHANGE_ATTRIBUTES)
 214         val |= DN_ATTRIB;
 215     if (filter & FILE_NOTIFY_CHANGE_SIZE)
 216         val |= DN_MODIFY;
 217     if (filter & FILE_NOTIFY_CHANGE_LAST_WRITE)
 218         val |= DN_MODIFY;
 219     if (filter & FILE_NOTIFY_CHANGE_LAST_ACCESS)
 220         val |= DN_ACCESS;
 221     if (filter & FILE_NOTIFY_CHANGE_CREATION)
 222         val |= DN_CREATE;
 223     if (filter & FILE_NOTIFY_CHANGE_SECURITY)
 224         val |= DN_ATTRIB;
 225     fcntl( fd, F_NOTIFY, val );
 226 #endif
 227 }
 228
 229 /* insert change in the global list */
 230 static inline void insert_change( struct dir *dir )
 231 {
 232     sigset_t sigset;
 233
 234     sigemptyset( &sigset );
 235     sigaddset( &sigset, SIGIO );
 236     sigprocmask( SIG_BLOCK, &sigset, NULL );
 237     list_add_head( &change_list, &dir->entry );
 238     sigprocmask( SIG_UNBLOCK, &sigset, NULL );
 239 }
 240
 241 /* remove change from the global list */
 242 static inline void remove_change( struct dir *dir )
 243 {
 244     sigset_t sigset;
 245
 246     sigemptyset( &sigset );
 247     sigaddset( &sigset, SIGIO );
 248     sigprocmask( SIG_BLOCK, &sigset, NULL );
 249     list_remove( &dir->entry );
 250     sigprocmask( SIG_UNBLOCK, &sigset, NULL );
 251 }
 252
 253 static void dir_dump( struct object *obj, int verbose )
 254 {
 255     struct dir *dir = (struct dir *)obj;
 256     assert( obj->ops == &dir_ops );
 257     fprintf( stderr, "Dirfile fd=%p event=%p filter=%08x\n",
 258              dir->fd, dir->event, dir->filter );
 259 }
 260
 261 static int dir_signaled( struct object *obj, struct thread *thread )
 262 {
 263     struct dir *dir = (struct dir *)obj;
 264     assert (obj->ops == &dir_ops);
 265     return (dir->event == NULL) && dir->signaled;
 266 }
 267
 268 /* enter here directly from SIGIO signal handler */
 269 void do_change_notify( int unix_fd )
 270 {
 271     struct dir *dir;
 272
 273     /* FIXME: this is O(n) ... probably can be improved */
 274     LIST_FOR_EACH_ENTRY( dir, &change_list, struct dir, entry )
 275     {
 276         if (get_unix_fd( dir->fd ) != unix_fd) continue;
 277         interlocked_xchg_add( &dir->notified, 1 );
 278         break;
 279     }
 280 }
 281
 282 static void dir_signal_changed( struct dir *dir )
 283 {
 284     if (dir->event)
 285         set_event( dir->event );
 286     else
 287         wake_up( &dir->obj, 0 );
 288 }
 289
 290 /* SIGIO callback, called synchronously with the poll loop */
 291 void sigio_callback(void)
 292 {
 293     struct dir *dir;
 294
 295     LIST_FOR_EACH_ENTRY( dir, &change_list, struct dir, entry )
 296     {
 297         long count = interlocked_xchg( &dir->notified, 0 );
 298         if (count)
 299         {
 300             dir->signaled += count;
 301             if (dir->signaled == count)  /* was it 0? */
 302                 dir_signal_changed( dir );
 303         }
 304     }
 305 }
 306
 307 static struct fd *dir_get_fd( struct object *obj )
 308 {
 309     struct dir *dir = (struct dir *)obj;
 310     assert( obj->ops == &dir_ops );
 311     return (struct fd *)grab_object( dir->fd );
 312 }
 313
 314 static unsigned int dir_map_access( struct object *obj, unsigned int access )
 315 {
 316     if (access & GENERIC_READ)    access |= FILE_GENERIC_READ;
 317     if (access & GENERIC_WRITE)   access |= FILE_GENERIC_WRITE;
 318     if (access & GENERIC_EXECUTE) access |= FILE_GENERIC_EXECUTE;
 319     if (access & GENERIC_ALL)     access |= FILE_ALL_ACCESS;
 320     return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
 321 }
 322
 323 static struct change_record *get_first_change_record( struct dir *dir )
 324 {
 325     struct list *ptr = list_head( &dir->change_records );
 326     if (!ptr) return NULL;
 327     list_remove( ptr );
 328     return LIST_ENTRY( ptr, struct change_record, entry );
 329 }
 330
 331 static void dir_destroy( struct object *obj )
 332 {
 333     struct change_record *record;
 334     struct dir *dir = (struct dir *)obj;
 335     assert (obj->ops == &dir_ops);
 336
 337     if (dir->filter)
 338         remove_change( dir );
 339
 340     if (dir->inode)
 341     {
 342         list_remove( &dir->in_entry );
 343         free_inode( dir->inode );
 344     }
 345
 346     async_terminate_queue( &dir->change_q, STATUS_CANCELLED );
 347     while ((record = get_first_change_record( dir ))) free( record );
 348
 349     if (dir->event)
 350     {
 351         set_event( dir->event );
 352         release_object( dir->event );
 353     }
 354     release_object( dir->fd );
 355
 356     if (inotify_fd && list_empty( &change_list ))
 357     {
 358         release_object( inotify_fd );
 359         inotify_fd = NULL;
 360     }
 361 }
 362
 363 static struct dir *
 364 get_dir_obj( struct process *process, obj_handle_t handle, unsigned int access )
 365 {
 366     return (struct dir *)get_handle_obj( process, handle, access, &dir_ops );
 367 }
 368
 369 static int dir_get_poll_events( struct fd *fd )
 370 {
 371     return 0;
 372 }
 373
 374 static int dir_get_info( struct fd *fd )
 375 {
 376     return 0;
 377 }
 378
 379 static void dir_cancel_async( struct fd *fd )
 380 {
 381     struct dir *dir = (struct dir *) get_fd_user( fd );
 382     async_terminate_queue( &dir->change_q, STATUS_CANCELLED );
 383 }
 384
 385
 386 #ifdef USE_INOTIFY
 387
 388 #define HASH_SIZE 31
 389
 390 struct inode {
 391     struct list dirs;        /* directory handles watching this inode */
 392     struct list ino_entry;   /* entry in the inode hash */
 393     struct list wd_entry;    /* entry in the watch descriptor hash */
 394     dev_t dev;               /* device number */
 395     ino_t ino;               /* device's inode number */
 396     int wd;                  /* inotify's watch descriptor */
 397 };
 398
 399 struct list inode_hash[ HASH_SIZE ];
 400 struct list wd_hash[ HASH_SIZE ];
 401
 402 static struct inode *inode_from_wd( int wd )
 403 {
 404     struct list *bucket = &wd_hash[ wd % HASH_SIZE ];
 405     struct inode *inode;
 406
 407     LIST_FOR_EACH_ENTRY( inode, bucket, struct inode, wd_entry )
 408         if (inode->wd == wd)
 409             return inode;
 410
 411     return NULL;
 412 }
 413
 414 static inline struct list *get_hash_list( dev_t dev, ino_t ino )
 415 {
 416     return &inode_hash[ (ino ^ dev) % HASH_SIZE ];
 417 }
 418
 419 static struct inode *get_inode( dev_t dev, ino_t ino )
 420 {
 421     struct list *bucket = get_hash_list( dev, ino );
 422     struct inode *inode;
 423
 424     LIST_FOR_EACH_ENTRY( inode, bucket, struct inode, ino_entry )
 425         if (inode->ino == ino && inode->dev == dev)
 426              return inode;
 427
 428     return NULL;
 429 }
 430
 431 static struct inode *create_inode( dev_t dev, ino_t ino )
 432 {
 433     struct inode *inode;
 434
 435     inode = malloc( sizeof *inode );
 436     if (inode)
 437     {
 438         list_init( &inode->dirs );
 439         inode->ino = ino;
 440         inode->dev = dev;
 441         inode->wd = -1;
 442         list_add_tail( get_hash_list( dev, ino ), &inode->ino_entry );
 443     }
 444     return inode;
 445 }
 446
 447 static void inode_set_wd( struct inode *inode, int wd )
 448 {
 449     if (inode->wd != -1)
 450         list_remove( &inode->wd_entry );
 451     inode->wd = wd;
 452     list_add_tail( &wd_hash[ wd % HASH_SIZE ], &inode->wd_entry );
 453 }
 454
 455 static void free_inode( struct inode *inode )
 456 {
 457     if (!list_empty( &inode->dirs ))
 458         return;
 459
 460     if (inode->wd != -1)
 461     {
 462         inotify_remove_watch( get_unix_fd( inotify_fd ), inode->wd );
 463         list_remove( &inode->wd_entry );
 464     }
 465     list_remove( &inode->ino_entry );
 466     free( inode );
 467 }
 468
 469 static int inotify_get_poll_events( struct fd *fd );
 470 static void inotify_poll_event( struct fd *fd, int event );
 471 static int inotify_get_info( struct fd *fd );
 472
 473 static const struct fd_ops inotify_fd_ops =
 474 {
 475     inotify_get_poll_events,  /* get_poll_events */
 476     inotify_poll_event,       /* poll_event */
 477     no_flush,                 /* flush */
 478     inotify_get_info,         /* get_file_info */
 479     default_fd_queue_async,   /* queue_async */
 480     default_fd_cancel_async,  /* cancel_async */
 481 };
 482
 483 static int inotify_get_poll_events( struct fd *fd )
 484 {
 485     return POLLIN;
 486 }
 487
 488 static void inotify_do_change_notify( struct dir *dir, struct inotify_event *ie )
 489 {
 490     struct change_record *record;
 491
 492     if (dir->want_data)
 493     {
 494         size_t len = strlen(ie->name);
 495         record = malloc( offsetof(struct change_record, name[len]) );
 496         if (!record)
 497             return;
 498
 499         if( ie->mask & IN_CREATE )
 500             record->action = FILE_ACTION_ADDED;
 501         else if( ie->mask & IN_DELETE )
 502             record->action = FILE_ACTION_REMOVED;
 503         else
 504             record->action = FILE_ACTION_MODIFIED;
 505         memcpy( record->name, ie->name, len );
 506         record->len = len;
 507
 508         list_add_tail( &dir->change_records, &record->entry );
 509     }
 510
 511     if (!list_empty( &dir->change_q ))
 512         async_terminate_head( &dir->change_q, STATUS_ALERTED );
 513     else
 514     {
 515         dir->signaled++;
 516         dir_signal_changed( dir );
 517     }
 518 }
 519
 520 static unsigned int filter_from_event( struct inotify_event *ie )
 521 {
 522     unsigned int filter = 0;
 523
 524     if (ie->mask & (IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE | IN_CREATE))
 525         filter |= FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME;
 526     if (ie->mask & IN_MODIFY)
 527         filter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
 528     if (ie->mask & IN_ATTRIB)
 529         filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES | FILE_NOTIFY_CHANGE_SECURITY;
 530     if (ie->mask & IN_ACCESS)
 531         filter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
 532     if (ie->mask & IN_CREATE)
 533         filter |= FILE_NOTIFY_CHANGE_CREATION;
 534
 535     return filter;
 536 }
 537
 538 static void inotify_notify_all( struct inotify_event *ie )
 539 {
 540     struct inode *inode;
 541     struct dir *dir;
 542     unsigned int filter;
 543
 544     inode = inode_from_wd( ie->wd );
 545     if (!inode)
 546     {
 547         fprintf( stderr, "no inode matches %d\n", ie->wd);
 548         return;
 549     }
 550
 551     filter = filter_from_event( ie );
 552
 553     LIST_FOR_EACH_ENTRY( dir, &inode->dirs, struct dir, in_entry )
 554         if (filter & dir->filter)
 555             inotify_do_change_notify( dir, ie );
 556 }
 557
 558 static void inotify_poll_event( struct fd *fd, int event )
 559 {
 560     int r, ofs, unix_fd;
 561     char buffer[0x1000];
 562     struct inotify_event *ie;
 563
 564     unix_fd = get_unix_fd( fd );
 565     r = read( unix_fd, buffer, sizeof buffer );
 566     if (r < 0)
 567     {
 568         fprintf(stderr,"inotify_poll_event(): inotify read failed!\n");
 569         return;
 570     }
 571
 572     for( ofs = 0; ofs < r - offsetof(struct inotify_event, name); )
 573     {
 574         ie = (struct inotify_event*) &buffer[ofs];
 575         if (!ie->len)
 576             break;
 577         ofs += offsetof( struct inotify_event, name[ie->len] );
 578         if (ofs > r) break;
 579         inotify_notify_all( ie );
 580     }
 581 }
 582
 583 static int inotify_get_info( struct fd *fd )
 584 {
 585     return 0;
 586 }
 587
 588 static inline struct fd *create_inotify_fd( void )
 589 {
 590     int unix_fd;
 591
 592     unix_fd = inotify_init();
 593     if (unix_fd<0)
 594         return NULL;
 595     return create_anonymous_fd( &inotify_fd_ops, unix_fd, NULL );
 596 }
 597
 598 static int map_flags( unsigned int filter )
 599 {
 600     unsigned int mask = 0;
 601
 602     if (filter & FILE_NOTIFY_CHANGE_FILE_NAME)
 603         mask |= (IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE | IN_CREATE);
 604     if (filter & FILE_NOTIFY_CHANGE_DIR_NAME)
 605         mask |= (IN_MOVED_FROM | IN_MOVED_TO | IN_DELETE | IN_CREATE | IN_DELETE_SELF);
 606     if (filter & FILE_NOTIFY_CHANGE_ATTRIBUTES)
 607         mask |= IN_ATTRIB;
 608     if (filter & FILE_NOTIFY_CHANGE_SIZE)
 609         mask |= IN_MODIFY;
 610     if (filter & FILE_NOTIFY_CHANGE_LAST_WRITE)
 611         mask |= IN_MODIFY;
 612     if (filter & FILE_NOTIFY_CHANGE_LAST_ACCESS)
 613         mask |= IN_ACCESS;
 614     if (filter & FILE_NOTIFY_CHANGE_CREATION)
 615         mask |= IN_CREATE;
 616     if (filter & FILE_NOTIFY_CHANGE_SECURITY)
 617         mask |= IN_ATTRIB;
 618
 619     return mask;
 620 }
 621
 622 static int inotify_add_dir( char *path, unsigned int filter )
 623 {
 624     int wd = inotify_add_watch( get_unix_fd( inotify_fd ),
 625                                 path, map_flags( filter ) );
 626     if (wd != -1)
 627         set_fd_events( inotify_fd, POLLIN );
 628     return wd;
 629 }
 630
 631 static unsigned int filter_from_inode( struct inode *inode )
 632 {
 633     unsigned int filter = 0;
 634     struct dir *dir;
 635
 636     LIST_FOR_EACH_ENTRY( dir, &inode->dirs, struct dir, in_entry )
 637         filter |= dir->filter;
 638
 639     return filter;
 640 }
 641
 642 static int init_inotify( void )
 643 {
 644     int i;
 645
 646     if (inotify_fd)
 647         return 1;
 648
 649     inotify_fd = create_inotify_fd();
 650     if (!inotify_fd)
 651         return 0;
 652
 653     for (i=0; i<HASH_SIZE; i++)
 654     {
 655         list_init( &inode_hash[i] );
 656         list_init( &wd_hash[i] );
 657     }
 658
 659     return 1;
 660 }
 661
 662 static int inotify_adjust_changes( struct dir *dir )
 663 {
 664     unsigned int filter;
 665     struct inode *inode;
 666     struct stat st;
 667     char path[32];
 668     int wd, unix_fd;
 669
 670     if (!inotify_fd)
 671         return 0;
 672
 673     unix_fd = get_unix_fd( dir->fd );
 674
 675     inode = dir->inode;
 676     if (!inode)
 677     {
 678         /* check if this fd is already being watched */
 679         if (-1 == fstat( unix_fd, &st ))
 680             return 0;
 681
 682         inode = get_inode( st.st_dev, st.st_ino );
 683         if (!inode)
 684             inode = create_inode( st.st_dev, st.st_ino );
 685         if (!inode)
 686             return 0;
 687         list_add_tail( &inode->dirs, &dir->in_entry );
 688         dir->inode = inode;
 689     }
 690
 691     filter = filter_from_inode( inode );
 692
 693     sprintf( path, "/proc/self/fd/%u", unix_fd );
 694     wd = inotify_add_dir( path, filter );
 695     if (wd == -1) return 0;
 696
 697     inode_set_wd( inode, wd );
 698
 699     return 1;
 700 }
 701
 702 #else
 703
 704 static int init_inotify( void )
 705 {
 706     return 0;
 707 }
 708
 709 static int inotify_adjust_changes( struct dir *dir )
 710 {
 711     return 0;
 712 }
 713
 714 static void free_inode( struct inode *inode )
 715 {
 716     assert( 0 );
 717 }
 718
 719 #endif  /* USE_INOTIFY */
 720
 721 struct object *create_dir_obj( struct fd *fd )
 722 {
 723     struct dir *dir;
 724
 725     dir = alloc_object( &dir_ops );
 726     if (!dir)
 727         return NULL;
 728
 729     list_init( &dir->change_q );
 730     list_init( &dir->change_records );
 731     dir->event = NULL;
 732     dir->filter = 0;
 733     dir->notified = 0;
 734     dir->signaled = 0;
 735     dir->want_data = 0;
 736     dir->inode = NULL;
 737     grab_object( fd );
 738     dir->fd = fd;
 739     set_fd_user( fd, &dir_fd_ops, &dir->obj );
 740
 741     return &dir->obj;
 742 }
 743
 744 /* enable change notifications for a directory */
 745 DECL_HANDLER(read_directory_changes)
 746 {
 747     struct event *event = NULL;
 748     struct dir *dir;
 749
 750     if (!req->filter)
 751     {
 752         set_error(STATUS_INVALID_PARAMETER);
 753         return;
 754     }
 755
 756     dir = get_dir_obj( current->process, req->handle, 0 );
 757     if (!dir)
 758         return;
 759
 760     /* possibly send changes through an event flag */
 761     if (req->event)
 762     {
 763         event = get_event_obj( current->process, req->event, EVENT_MODIFY_STATE );
 764         if (!event)
 765             goto end;
 766     }
 767
 768     /* discard the current data, and move onto the next event */
 769     if (dir->event) release_object( dir->event );
 770     dir->event = event;
 771
 772     /* requests don't timeout */
 773     if ( req->io_apc && !create_async( current, NULL, &dir->change_q,
 774                         req->io_apc, req->io_user, req->io_sb ))
 775         return;
 776
 777     /* assign it once */
 778     if (!dir->filter)
 779     {
 780         init_inotify();
 781         insert_change( dir );
 782         dir->filter = req->filter;
 783         dir->want_data = req->want_data;
 784     }
 785
 786     /* remove any notifications */
 787     if (dir->signaled>0)
 788         dir->signaled--;
 789
 790     /* clear the event */
 791     if (event)
 792         reset_event( event );
 793
 794     /* setup the real notification */
 795     if (!inotify_adjust_changes( dir ))
 796         dnotify_adjust_changes( dir );
 797
 798     set_error(STATUS_PENDING);
 799
 800 end:
 801     release_object( dir );
 802 }
 803
 804 DECL_HANDLER(read_change)
 805 {
 806     struct change_record *record;
 807     struct dir *dir;
 808
 809     dir = get_dir_obj( current->process, req->handle, 0 );
 810     if (!dir)
 811         return;
 812
 813     if ((record = get_first_change_record( dir )) != NULL)
 814     {
 815         reply->action = record->action;
 816         set_reply_data( record->name, record->len );
 817         free( record );
 818     }
 819     else
 820         set_error( STATUS_NO_DATA_DETECTED );
 821
 822     /* now signal it */
 823     dir->signaled++;
 824     dir_signal_changed( dir );
 825
 826     release_object( dir );
 827 }