monitor_inotify.c

   1 /* MiniDLNA media server
   2  * Copyright (C) 2008-2010  Justin Maggard
   3  *
   4  * This file is part of MiniDLNA.
   5  *
   6  * MiniDLNA is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * MiniDLNA is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with MiniDLNA. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #include "config.h"
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdbool.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <pthread.h>
  26 #include <unistd.h>
  27 #include <dirent.h>
  28 #include <libgen.h>
  29 #include <signal.h>
  30 #include <errno.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <sys/time.h>
  34 #ifdef HAVE_INOTIFY
  35 #include <sys/resource.h>
  36 #include <poll.h>
  37 #ifdef HAVE_SYS_INOTIFY_H
  38 #include <sys/inotify.h>
  39 #else
  40 #include "linux/inotify.h"
  41 #include "linux/inotify-syscalls.h"
  42 #endif
  43 #endif
  44 #include "libav.h"
  45
  46 #include "upnpglobalvars.h"
  47 #include "monitor.h"
  48 #include "utils.h"
  49 #include "sql.h"
  50 #include "scanner.h"
  51 #include "metadata.h"
  52 #include "albumart.h"
  53 #include "playlist.h"
  54 #include "log.h"
  55
  56 extern time_t next_pl_fill;
  57
  58 #define EVENT_SIZE  ( sizeof (struct inotify_event) )
  59 #define BUF_LEN     ( 1024 * ( EVENT_SIZE + 16 ) )
  60 #define DESIRED_WATCH_LIMIT 65536
  61
  62 #define PATH_BUF_SIZE PATH_MAX
  63
  64 struct watch
  65 {
  66         int wd;         /* watch descriptor */
  67         char *path;     /* watched path */
  68         struct watch *next;
  69 };
  70
  71 static struct watch *watches;
  72 static struct watch *lastwatch = NULL;
  73 static pthread_t thread_id;
  74
  75 static char *
  76 get_path_from_wd(int wd)
  77 {
  78         struct watch *w = watches;
  79
  80         while( w != NULL )
  81         {
  82                 if( w->wd == wd )
  83                         return w->path;
  84                 w = w->next;
  85         }
  86
  87         return NULL;
  88 }
  89
  90 static unsigned int
  91 next_highest(unsigned int num)
  92 {
  93         num |= num >> 1;
  94         num |= num >> 2;
  95         num |= num >> 4;
  96         num |= num >> 8;
  97         num |= num >> 16;
  98         return ++num;
  99 }
 100
 101 static void
 102 raise_watch_limit(unsigned int limit)
 103 {
 104         FILE *max_watches = fopen("/proc/sys/fs/inotify/max_user_watches", "r+");
 105         if (!max_watches)
 106                 return;
 107         if (!limit)
 108         {
 109                 if (fscanf(max_watches, "%u", &limit) < 1)
 110                         limit = 8192;
 111                 rewind(max_watches);
 112         }
 113         fprintf(max_watches, "%u", next_highest(limit));
 114         fclose(max_watches);
 115 }
 116
 117 int
 118 monitor_add_watch(int fd, const char * path)
 119 {
 120         struct watch *nw;
 121         int wd;
 122
 123         wd = inotify_add_watch(fd, path, IN_CREATE|IN_CLOSE_WRITE|IN_DELETE|IN_MOVE);
 124         if( wd < 0 && errno == ENOSPC)
 125         {
 126                 raise_watch_limit(0);
 127                 wd = inotify_add_watch(fd, path, IN_CREATE|IN_CLOSE_WRITE|IN_DELETE|IN_MOVE);
 128         }
 129         if( wd < 0 )
 130         {
 131                 DPRINTF(E_ERROR, L_INOTIFY, "inotify_add_watch(%s) [%s]\n", path, strerror(errno));
 132                 return (errno);
 133         }
 134
 135         nw = malloc(sizeof(struct watch));
 136         if( nw == NULL )
 137         {
 138                 DPRINTF(E_ERROR, L_INOTIFY, "malloc() error\n");
 139                 return (ENOMEM);
 140         }
 141         nw->wd = wd;
 142         nw->next = NULL;
 143         nw->path = strdup(path);
 144
 145         if( watches == NULL )
 146         {
 147                 watches = nw;
 148         }
 149
 150         if( lastwatch != NULL )
 151         {
 152                 lastwatch->next = nw;
 153         }
 154         lastwatch = nw;
 155
 156         DPRINTF(E_INFO, L_INOTIFY, "Added watch to %s [%d]\n", path, wd);
 157         return (0);
 158 }
 159
 160 int
 161 monitor_remove_watch(int fd, const char * path)
 162 {
 163         struct watch *w;
 164
 165         for( w = watches; w; w = w->next )
 166         {
 167                 if( strcmp(path, w->path) == 0 )
 168                         return(inotify_rm_watch(fd, w->wd));
 169         }
 170
 171         return 1;
 172 }
 173
 174 static int
 175 inotify_create_watches(int fd)
 176 {
 177         FILE * max_watches;
 178         unsigned int num_watches = 0, watch_limit;
 179         char **result;
 180         int i, rows = 0;
 181         struct media_dir_s * media_path;
 182
 183         for( media_path = media_dirs; media_path != NULL; media_path = media_path->next )
 184         {
 185                 DPRINTF(E_DEBUG, L_INOTIFY, "Add watch to %s\n", media_path->path);
 186                 monitor_add_watch(fd, media_path->path);
 187                 num_watches++;
 188         }
 189         sql_get_table(db, "SELECT PATH from DETAILS where MIME is NULL and PATH is not NULL", &result, &rows, NULL);
 190         for( i=1; i <= rows; i++ )
 191         {
 192                 DPRINTF(E_DEBUG, L_INOTIFY, "Add watch to %s\n", result[i]);
 193                 monitor_add_watch(fd, result[i]);
 194                 num_watches++;
 195         }
 196         sqlite3_free_table(result);
 197
 198         max_watches = fopen("/proc/sys/fs/inotify/max_user_watches", "r");
 199         if( max_watches )
 200         {
 201                 if( fscanf(max_watches, "%10u", &watch_limit) < 1 )
 202                         watch_limit = 8192;
 203                 fclose(max_watches);
 204                 if( (watch_limit < DESIRED_WATCH_LIMIT) || (watch_limit < (num_watches*4/3)) )
 205                 {
 206                         if (access("/proc/sys/fs/inotify/max_user_watches", W_OK) == 0)
 207                         {
 208                                 if( DESIRED_WATCH_LIMIT >= (num_watches*3/4) )
 209                                 {
 210                                         raise_watch_limit(8191U);
 211                                 }
 212                                 else if( next_highest(num_watches) >= (num_watches*3/4) )
 213                                 {
 214                                         raise_watch_limit(num_watches);
 215                                 }
 216                                 else
 217                                 {
 218                                         raise_watch_limit(next_highest(num_watches));
 219                                 }
 220                         }
 221                         else
 222                         {
 223                                 DPRINTF(E_WARN, L_INOTIFY, "WARNING: Inotify max_user_watches [%u] is low or close to the number of used watches [%u] "
 224                                                         "and I do not have permission to increase this limit.  Please do so manually by "
 225                                                         "writing a higher value into /proc/sys/fs/inotify/max_user_watches.\n", watch_limit, num_watches);
 226                         }
 227                 }
 228         }
 229         else
 230         {
 231                 DPRINTF(E_WARN, L_INOTIFY, "WARNING: Could not read inotify max_user_watches!  "
 232                                         "Hopefully it is enough to cover %u current directories plus any new ones added.\n", num_watches);
 233         }
 234
 235         return rows;
 236 }
 237
 238 static int
 239 inotify_remove_watches(int fd)
 240 {
 241         struct watch *w = watches;
 242         struct watch *last_w;
 243         int rm_watches = 0;
 244
 245         while( w )
 246         {
 247                 last_w = w;
 248                 inotify_rm_watch(fd, w->wd);
 249                 free(w->path);
 250                 rm_watches++;
 251                 w = w->next;
 252                 free(last_w);
 253         }
 254
 255         return rm_watches;
 256 }
 257
 258 static void *
 259 inotify_thread(void *arg)
 260 {
 261         struct pollfd pollfds[1];
 262         char buffer[BUF_LEN];
 263         char path_buf[PATH_MAX];
 264         int length, i = 0;
 265         char * esc_name = NULL;
 266         struct stat st;
 267         sigset_t set;
 268
 269         sigfillset(&set);
 270         sigdelset(&set, SIGCHLD);
 271         pthread_sigmask(SIG_BLOCK, &set, NULL);
 272
 273         pollfds[0].fd = inotify_init();
 274         pollfds[0].events = POLLIN;
 275
 276         if ( pollfds[0].fd < 0 )
 277                 DPRINTF(E_ERROR, L_INOTIFY, "inotify_init() failed!\n");
 278
 279         inotify_create_watches(pollfds[0].fd);
 280         if (setpriority(PRIO_PROCESS, 0, 19) == -1)
 281                 DPRINTF(E_WARN, L_INOTIFY,  "Failed to reduce inotify thread priority\n");
 282         sqlite3_release_memory(1<<31);
 283
 284         while( !quitting )
 285         {
 286                 int timeout = -1;
 287                 if (next_pl_fill)
 288                 {
 289                         time_t diff = next_pl_fill - time(NULL);
 290                         if (diff < 0)
 291                                 timeout = 0;
 292                         else
 293                                 timeout = diff * 1000;
 294                 }
 295                 length = poll(pollfds, 1, timeout);
 296                 if( !length )
 297                 {
 298                         if( next_pl_fill && (time(NULL) >= next_pl_fill) )
 299                         {
 300                                 fill_playlists();
 301                                 next_pl_fill = 0;
 302                         }
 303                         continue;
 304                 }
 305                 else if( length < 0 )
 306                 {
 307                         if( (errno == EINTR) || (errno == EAGAIN) )
 308                                 continue;
 309                         else
 310                                 DPRINTF(E_ERROR, L_INOTIFY, "read failed!\n");
 311                 }
 312                 else
 313                 {
 314                         length = read(pollfds[0].fd, buffer, BUF_LEN);
 315                         buffer[BUF_LEN-1] = '\0';
 316                 }
 317
 318                 i = 0;
 319                 while( !quitting && i < length )
 320                 {
 321                         struct inotify_event * event = (struct inotify_event *) &buffer[i];
 322                         if( event->len )
 323                         {
 324                                 if( *(event->name) == '.' )
 325                                 {
 326                                         i += EVENT_SIZE + event->len;
 327                                         continue;
 328                                 }
 329                                 esc_name = modifyString(strdup(event->name), "&", "&amp;amp;", 0);
 330                                 snprintf(path_buf, sizeof(path_buf), "%s/%s", get_path_from_wd(event->wd), event->name);
 331                                 if ( event->mask & IN_ISDIR && (event->mask & (IN_CREATE|IN_MOVED_TO)) )
 332                                 {
 333                                         DPRINTF(E_DEBUG, L_INOTIFY,  "The directory %s was %s.\n",
 334                                                 path_buf, (event->mask & IN_MOVED_TO ? "moved here" : "created"));
 335                                         monitor_insert_directory(pollfds[0].fd, esc_name, path_buf);
 336                                 }
 337                                 else if ( (event->mask & (IN_CLOSE_WRITE|IN_MOVED_TO|IN_CREATE)) &&
 338                                           (lstat(path_buf, &st) == 0) )
 339                                 {
 340                                         if( (event->mask & (IN_MOVED_TO|IN_CREATE)) && (S_ISLNK(st.st_mode) || st.st_nlink > 1) )
 341                                         {
 342                                                 DPRINTF(E_DEBUG, L_INOTIFY, "The %s link %s was %s.\n",
 343                                                         (S_ISLNK(st.st_mode) ? "symbolic" : "hard"),
 344                                                         path_buf, (event->mask & IN_MOVED_TO ? "moved here" : "created"));
 345                                                 if( stat(path_buf, &st) == 0 && S_ISDIR(st.st_mode) )
 346                                                         monitor_insert_directory(pollfds[0].fd, esc_name, path_buf);
 347                                                 else
 348                                                         monitor_insert_file(esc_name, path_buf);
 349                                         }
 350                                         else if( event->mask & (IN_CLOSE_WRITE|IN_MOVED_TO) && st.st_size > 0 )
 351                                         {
 352                                                 if( (event->mask & IN_MOVED_TO) ||
 353                                                     (sql_get_int_field(db, "SELECT TIMESTAMP from DETAILS where PATH = '%q'", path_buf) != st.st_mtime) )
 354                                                 {
 355                                                         DPRINTF(E_DEBUG, L_INOTIFY, "The file %s was %s.\n",
 356                                                                 path_buf, (event->mask & IN_MOVED_TO ? "moved here" : "changed"));
 357                                                         monitor_insert_file(esc_name, path_buf);
 358                                                 }
 359                                         }
 360                                 }
 361                                 else if ( event->mask & (IN_DELETE|IN_MOVED_FROM) )
 362                                 {
 363                                         DPRINTF(E_DEBUG, L_INOTIFY, "The %s %s was %s.\n",
 364                                                 (event->mask & IN_ISDIR ? "directory" : "file"),
 365                                                 path_buf, (event->mask & IN_MOVED_FROM ? "moved away" : "deleted"));
 366                                         if ( event->mask & IN_ISDIR )
 367                                                 monitor_remove_directory(pollfds[0].fd, path_buf);
 368                                         else
 369                                         {
 370                                                 monitor_remove_file(path_buf);
 371                                                 /*
 372                                                  * When a symlink to a directory is deleted
 373                                                  * we cannot tell it from a regular file deletion
 374                                                  * to prevent its children from becoming orphans
 375                                                  * we delete the whole tree when it exists
 376                                                  */
 377                                                 monitor_remove_tree(path_buf);
 378                                         }
 379                                 }
 380                                 free(esc_name);
 381                         }
 382                         i += EVENT_SIZE + event->len;
 383                 }
 384         }
 385         inotify_remove_watches(pollfds[0].fd);
 386         close(pollfds[0].fd);
 387
 388         return 0;
 389 }
 390
 391 void
 392 monitor_start(void)
 393 {
 394
 395         if (!sqlite3_threadsafe() || sqlite3_libversion_number() < 3005001) {
 396                 DPRINTF(E_ERROR, L_GENERAL, "SQLite library is not threadsafe!"
 397                     "Inotify will be disabled.\n");
 398                 return;
 399         }
 400         if (pthread_create(&thread_id, NULL, inotify_thread, NULL) != 0)
 401                 DPRINTF(E_FATAL, L_GENERAL, "pthread_create() failed [%s]\n",
 402                     strerror(errno));
 403 }
 404
 405 void
 406 monitor_stop(void)
 407 {
 408
 409         if (thread_id != 0) {
 410                 pthread_kill(thread_id, SIGCHLD);
 411                 pthread_join(thread_id, NULL);
 412         }
 413 }