linux/unix系统编程手册附录代码

/*************************************************************************\ * Copyright (C) Michael Kerrisk, 2020. * * * * This program is free software. You may use, modify, and redistribute it * * under the terms of the GNU General Public License as published by the * * Free Software Foundation, either version 3 or (at your option) any * * later version. This program is distributed without any warranty. See * * the file COPYING.gpl-v3 for details. * \*************************************************************************/ /* Supplementary program for Chapter 19 */ /* Known limitations - Pathnames longer than PATH_MAX are not handled. */ #define _GNU_SOURCE #include <sys/select.h> #include <sys/stat.h> #include <limits.h> #include <sys/select.h> #include <sys/inotify.h> #include <fcntl.h> #include <ftw.h> #include <signal.h> #include <stdarg.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <errno.h> #define errExit(msg) do { perror(msg); exit(EXIT_FAILURE); \ } while (0) /* logMessage() flags */ #define VB_BASIC 1 /* Basic messages */ #define VB_NOISY 2 /* Verbose messages */ static int verboseMask; static int checkCache; static int dumpCache; static int readBufferSize = 0; static char *stopFile; static int abortOnCacheProblem; static FILE *logfp = NULL; static int inotifyReadCnt = 0; /* Counts number of read()s from inotify file descriptor */ static const int INOTIFY_READ_BUF_LEN = (100 * (sizeof(struct inotify_event) + NAME_MAX + 1)); static void dumpCacheToLog(void); /* Something went badly wrong. Create a 'stop' file to signal the 'rand_dtree' processes to stop, dump a copy of the cache to the log file, and abort. */ __attribute__ ((__noreturn__)) static void createStopFileAndAbort(void) { open(stopFile, O_CREAT | O_RDWR, 0600); dumpCacheToLog(); abort(); } /* Write a log message. The message is sent to none, either, or both of stderr and the log file, depending on 'vb_mask' and whether a log file has been specified via command-line options . */ static void logMessage(int vb_mask, const char *format, ...) { va_list argList; /* Write message to stderr if 'vb_mask' is zero, or matches one of the bits in 'verboseMask' */ if ((vb_mask == 0) || (vb_mask & verboseMask)) { va_start(argList, format); vfprintf(stderr, format, argList); va_end(argList); } /* If we have a log file, write the message there */ if (logfp != NULL) { va_start(argList, format); vfprintf(logfp, format, argList); va_end(argList); } } /***********************************************************************/ /* Display some information about an inotify event. (Used when when we are doing verbose logging.) */ static void displayInotifyEvent(struct inotify_event *ev) { logMessage(VB_NOISY, "==> wd = %d; ", ev->wd); if (ev->cookie > 0) logMessage(VB_NOISY, "cookie = %4d; ", ev->cookie); logMessage(VB_NOISY, "mask = "); if (ev->mask & IN_ISDIR) logMessage(VB_NOISY, "IN_ISDIR "); if (ev->mask & IN_CREATE) logMessage(VB_NOISY, "IN_CREATE "); if (ev->mask & IN_DELETE_SELF) logMessage(VB_NOISY, "IN_DELETE_SELF "); if (ev->mask & IN_MOVE_SELF) logMessage(VB_NOISY, "IN_MOVE_SELF "); if (ev->mask & IN_MOVED_FROM) logMessage(VB_NOISY, "IN_MOVED_FROM "); if (ev->mask & IN_MOVED_TO) logMessage(VB_NOISY, "IN_MOVED_TO "); if (ev->mask & IN_IGNORED) logMessage(VB_NOISY, "IN_IGNORED "); if (ev->mask & IN_Q_OVERFLOW) logMessage(VB_NOISY, "IN_Q_OVERFLOW "); if (ev->mask & IN_UNMOUNT) logMessage(VB_NOISY, "IN_UNMOUNT "); logMessage(VB_NOISY, "\n"); if (ev->len > 0) logMessage(VB_NOISY, " name = %s\n", ev->name); } /***********************************************************************/ /* Data structures and functions for the watch list cache */ /* We use a very simple data structure for caching watched directory paths: a dynamically sized array that is searched linearly. Not efficient, but our main goal is to demonstrate the use of inotify. */ struct watch { int wd; /* Watch descriptor (-1 if slot unused) */ char path[PATH_MAX]; /* Cached pathname */ }; struct watch *wlCache = NULL; /* Array of cached items */ static int cacheSize = 0; /* Current size of the array */ /* Deallocate the watch cache */ static void freeCache(void) { free(wlCache); cacheSize = 0; wlCache = NULL; } /* Check that all pathnames in the cache are valid, and refer to directories */ static void checkCacheConsistency(void) { int failures; struct stat sb; failures = 0; for (int j = 0; j < cacheSize; j++) { if (wlCache[j].wd >= 0) { if (lstat(wlCache[j].path, &sb) == -1) { logMessage(0, "checkCacheConsistency: stat: " "[slot = %d; wd = %d] %s: %s\n", j, wlCache[j].wd, wlCache[j].path, strerror(errno)); failures++; } else if (!S_ISDIR(sb.st_mode)) { logMessage(0, "checkCacheConsistency: %s is not a directory\n", wlCache[j].path); exit(EXIT_FAILURE); } } } if (failures > 0) logMessage(VB_NOISY, "checkCacheConsistency: %d failures\n", failures); } /* Check whether the cache contains the watch descriptor 'wd'. If found, return the slot number, otherwise return -1. */ static int findWatch(int wd) { for (int j = 0; j < cacheSize; j++) if (wlCache[j].wd == wd) return j; return -1; } /* Find and return the cache slot for the watch descriptor 'wd'. The caller expects this watch descriptor to exist. If it does not, there is a problem, which is signaled by the -1 return. */ static int findWatchChecked(int wd) { int slot; slot = findWatch(wd); if (slot >= 0) return slot; logMessage(0, "Could not find watch %d\n", wd); /* With multiple renamers there are still rare cases where the cache is missing entries after a 'Could not find watch' event. It looks as though this is because of races with nftw(), since the cache is (occasionally) re-created with fewer entries than there are objects in the tree(s). Returning -1 to our caller identifies that there's a problem, and the caller should probably trigger a cache rebuild. */ if (abortOnCacheProblem) { createStopFileAndAbort(); } else { return -1; } } /* Mark a cache entry as unused */ static void markCacheSlotEmpty(int slot) { logMessage(VB_NOISY, " markCacheSlotEmpty: slot = %d; wd = %d; path = %s\n", slot, wlCache[slot].wd, wlCache[slot].path); wlCache[slot].wd = -1; wlCache[slot].path[0] = '\0'; } /* Find a free slot in the cache */ static int findEmptyCacheSlot(void) { const int ALLOC_INCR = 200; for (int j = 0; j < cacheSize; j++) if (wlCache[j].wd == -1) return j; /* No free slot found; resize cache */ cacheSize += ALLOC_INCR; wlCache = realloc(wlCache, cacheSize * sizeof(struct watch)); if (wlCache == NULL) errExit("realloc"); for (int j = cacheSize - ALLOC_INCR; j < cacheSize; j++) markCacheSlotEmpty(j); return cacheSize - ALLOC_INCR; /* Return first slot in newly allocated space */ } /* Add an item to the cache */ static int addWatchToCache(int