[BZ #14906]

	* nscd/cache.c (prune_cache): Use TRACED_FILE.

	* nscd/connections.c [HAVE_INOTIFY] (install_watches): New function.

	(register_traced_file): Call install_watches. Don't set unused mtime.

	(invalidate_cache): Call install_watches.

	(inotify_check_files): Don't inline. Handle watching parent

	directories and configuration file movement in and out.

	(handle_inotify_events): New function.

	(main_loop_poll): Call handle_inotify_events.

	(main_loop_epoll): Likewise.

	* nscd/nscd.h: Define TRACED_FILE, TRACED_DIR, and PATH_MAX.

	(struct traced_file): Remove unused mtime. Use array of inotify fds.

	Add parent directory, and basename.

	(init_traced_file): New inline function.

	(define_traced_file): New macro.

	* nss/nss_db/db-init.c: Use define_traced_file.

	(_nss_db_init): Use init_traced_file.

	* nss/nss_files/files-init.c: Use define_traced_file.

	(_nss_files_init): Use init_traced_file.

2015-02-17  Carlos O'Donell  <carlos@redhat.com>

#ifdef HAVE_INOTIFY

#define TRACED_FILE_MASK (IN_DELETE_SELF | IN_CLOSE_WRITE | IN_MOVE_SELF)

#define TRACED_DIR_MASK (IN_DELETE_SELF | IN_CREATE | IN_MOVED_TO | IN_MOVE_SELF)

void

install_watches (struct traced_file *finfo)

{

  /* If we have inotify support use it exclusively with no fallback

     to stat.  This is a design decision to make the implementation

     sipmler.  Either we use fstat for the file name or we use inotify

     for both the file and parent directory.  */

  if (finfo->inotify_descr[TRACED_FILE] < 0)

    finfo->inotify_descr[TRACED_FILE] = inotify_add_watch (inotify_fd,

							   finfo->fname,

							   TRACED_FILE_MASK);

  if (finfo->inotify_descr[TRACED_FILE] < 0)

    {

      dbg_log (_("failed to add watch to file `%s': %s"),

		 finfo->fname, strerror (errno));

      return;

    }

  dbg_log (_("watching registered file `%s` (%d)"),

	   finfo->fname, finfo->inotify_descr[TRACED_FILE]);

  /* Additionally listen for IN_CREATE events in the files parent

     directory.  We do this because the file to be watched might be

     deleted and then added back again.  When it is added back again

     we must re-add the watch.  We must also cover IN_MOVED_TO to

     detect a file being moved into the directory.  */

  if (finfo->inotify_descr[TRACED_DIR] < 0)

    finfo->inotify_descr[TRACED_DIR] = inotify_add_watch (inotify_fd,

							  finfo->dname,

							  TRACED_DIR_MASK);

  if (finfo->inotify_descr[TRACED_DIR] < 0)

    {

      dbg_log (_("failed to add watch to directory `%s': %s"),

		 finfo->fname, strerror (errno));

      return;

    }

  dbg_log (_("watching registered directory `%s` (%d)"),

	   finfo->dname, finfo->inotify_descr[TRACED_DIR]);

}

#endif

	      }

	      dbg_log (_("registered file `%s` was written to"), finfo->fname);

	  /* The parent directory was moved or deleted.  There is no coming

	     back from this.  We do not track the parent of the parent, and

	     once this happens we trigger one last invalidation.  You must

	     restart nscd to track subsequent changes.   We track this to

	     do one last robust re-initialization and then we're done.  */

	  if (finfo->inotify_descr[TRACED_DIR] == inev->i.wd

	      && ((inev->i.mask & IN_DELETE_SELF)

		  || (inev->i.mask & IN_MOVE_SELF)

		  || (inev->i.mask & IN_IGNORED)))

	    {

	      bool moved = (inev->i.mask & IN_MOVE_SELF) != 0;

	      /* The directory watch may have already been removed

		 but we don't know so we just remove it again and

		 ignore the error.  Then we remove the file watch.

		 Note: watches are automatically removed for deleted

		 files.  */

	      if (moved)

		inotify_rm_watch (inotify_fd, inev->i.wd);

	      if (finfo->inotify_descr[TRACED_FILE] != -1)

		{

		  dbg_log (_("registered parent directory `%s` was %s, removing watch on `%s`"),

			   finfo->dname, moved ? "moved" : "deleted", finfo->fname);

		  if (inotify_rm_watch (inotify_fd, finfo->inotify_descr[TRACED_FILE]) < 0)

		    dbg_log (_("failed to remove file watch `%s`: %s"),

			     finfo->dname, strerror (errno));

		}

	      finfo->inotify_descr[TRACED_FILE] = -1;

	      finfo->inotify_descr[TRACED_DIR] = -1;

	      to_clear[dbcnt] = true;

	      if (finfo->call_res_init)

	        res_init ();

	      /* Continue to the next entry since this might be the

		 parent directory for multiple registered files and

		 we want to remove watches for all registered files.  */

	      continue;

	    }

	  /* The parent directory had a create or moved to event.  */

	  if (finfo->inotify_descr[TRACED_DIR] == inev->i.wd

	      && strcmp (inev->i.name, finfo->sfname) == 0)

	    {

	      /* We detected a directory change.  We look for the creation

		 of the file we are tracking or the move of the same file

		 into the directory.  */

	      int ret;

	      dbg_log (_("registered file `%s` was %s, adding watch"),

		       finfo->fname,

		       inev->i.mask & IN_CREATE ? "created" : "moved into place");

	      /* File was moved in or created.  Regenerate the watch.  */

	      if (finfo->inotify_descr[TRACED_FILE] != -1)

		{

		  ret = inotify_rm_watch (inotify_fd,

					  finfo->inotify_descr[TRACED_FILE]);

		  if (ret < 0)

		    dbg_log (_("failed to remove file watch `%s`: %s"),

			     finfo->fname, strerror (errno));

		}

	      ret = inotify_add_watch (inotify_fd,

				       finfo->fname,

				       TRACED_FILE_MASK);

	      if (ret < 0)

		dbg_log (_("failed to add file watch `%s`: %s"),

			 finfo->fname, strerror (errno));

	      finfo->inotify_descr[TRACED_FILE] = ret;

	      /* The file is new or moved so mark cache as needing to

		 be cleared and reinitialize.  */

	      to_clear[dbcnt] = true;

	      if (finfo->call_res_init)

		res_init ();

	      /* Done re-adding the watch.  Don't return, we may still

		 have other files in this same directory, same watch

		 descriptor, and need to process them.  */

	    }

int

handle_inotify_events (void)

{

  bool to_clear[lastdb] = { false, };

  union __inev inev;

  /* Read all inotify events for files registered via

     register_traced_file().  */

  while (1)

    {

      /* Potentially read multiple events into buf.  */

      ssize_t nb = TEMP_FAILURE_RETRY (read (inotify_fd,

					     &inev.buf,

					     sizeof (inev)));

      if (nb < (ssize_t) sizeof (struct inotify_event))

	{

	  /* Not even 1 event.  */

	  if (__glibc_unlikely (nb == -1 && errno != EAGAIN))

	    return -1;

	  /* Done reading events that are ready.  */

	  break;

	}

      /* Process all events.  The normal inotify interface delivers

	 complete events on a read and never a partial event.  */

      char *eptr = &inev.buf[0];

      ssize_t count;

      while (1)

	{

	  /* Check which of the files changed.  */

	  inotify_check_files (to_clear, &inev);

	  count = sizeof (struct inotify_event) + inev.i.len;

	  eptr += count;

	  nb -= count;

	  if (nb >= (ssize_t) sizeof (struct inotify_event))

	    memcpy (&inev, eptr, nb);

	  else

	    break;

	}

      continue;

    }

  /* Actually perform the cache clearing.  */

  clear_db_cache (to_clear);

  return 0;

}

/* Initialize a `struct traced_file`.  As input we need the name

   of the file, and if invalidation requires calling res_init.

   If CRINIT is 1 then res_init will be called after invalidation

   or if the traced file is changed in any way, otherwise it will

   not.  */

static inline void

init_traced_file(struct traced_file *file, const char *fname, int crinit)

{

   char *dname;

   file->inotify_descr[TRACED_FILE] = -1;

   file->inotify_descr[TRACED_DIR] = -1;

   strcpy (file->fname, fname);

   /* Compute the parent directory name and store a copy.  The copy makes

      it much faster to add/remove watches while nscd is running instead

      of computing this over and over again in a temp buffer.  */

   file->dname[0] = '\0';

   dname = strrchr (fname, '/');

   if (dname != NULL)

     {

       size_t len = (size_t)(dname - fname);

       if (len > sizeof (file->dname))

	 abort ();

       strncpy (file->dname, file->fname, len);

       file->dname[len] = '\0';

     }

   /* The basename is the name just after the last forward slash.  */

   file->sfname = &dname[1];

   file->call_res_init = crinit;

}

#define define_traced_file(id, filename) 			\

static union							\

{								\

  struct traced_file file;					\

  char buf[sizeof (struct traced_file) + sizeof (filename)];	\

} id##_traced_file;

#define SERV_FILENAME (_PATH_VARDB "services.db")

define_traced_file (serv, SERV_FILENAME);

#define PWD_FILENAME "/etc/passwd"

define_traced_file (pwd, PWD_FILENAME);

#define HST_FILENAME "/etc/hosts"

define_traced_file (hst, HST_FILENAME);

#define RESOLV_FILENAME "/etc/resolv.conf"

define_traced_file (resolv, RESOLV_FILENAME);

#define SERV_FILENAME "/etc/services"

define_traced_file (serv, SERV_FILENAME);

#define NETGR_FILENAME "/etc/netgroup"

define_traced_file (netgr, NETGR_FILENAME);