使用信号处理linux文件系统监视，(if no inotify)

linux下c的代码原型如下：
#define _GNU_SOURCE

#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

static volatile int event_fd;

static void handler(int signum, siginfo_t *si, void *data){
    event_fd = si->si_fd;
    printf("info size:%d, data:%d/n", sizeof(siginfo_t), sizeof(data));
}

int main(int argc, char **argv){
    struct sigaction action;
    int fd;
    action.sa_sigaction = handler;
    sigemptyset(&action.sa_mask);
    action.sa_flags = SA_SIGINFO;
    sigaction(SIGRTMIN+1, &action, NULL);
   
    fd = open("test", O_RDONLY);
    fcntl(fd, F_SETSIG, SIGRTMIN+1);
    fcntl(fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_MULTISHOT);

    fd = open(".", O_RDONLY);
    fcntl(fd, F_SETSIG, SIGRTMIN+1);
    fcntl(fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_MULTISHOT);
    while(1){
        pause();
        printf("got event on fd=%d/n", event_fd);
    }
}
 

我要使用python，可以使用嵌入式方式，如果不是嵌入式方式，将会有1个以上的进程出现。
//#define _GNU_SOURCE
#include "Python.h"
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>

typedef void my_handler_t(int, int);
typedef my_handler_t * my_handler;

static void * current_handler;

static volatile int event_fd;
static void default_handler(int signum, siginfo_t * siginfo, void * context){
    event_fd = siginfo->si_fd;
    printf("event_fd %d, %p, sizeof /n", event_fd, siginfo);
    //current_handler(signum, siginfo->si_fd);

    PyObject *arglist = Py_BuildValue("(ii)", signum, siginfo->si_fd);
    PyObject_Print(arglist, stdout, Py_PRINT_RAW);
    printf("arglist end/n");

    PyGILState_STATE state;
    state = PyGILState_Ensure();

    Py_INCREF(arglist);
    PyObject *result =
    PyEval_CallObject(current_handler, arglist);
    Py_DECREF(arglist);

    PyGILState_Release(state);
    PyObject_Print(result, stdout, Py_PRINT_RAW);
    printf("-->result %p/n", result);
    //TODO: PyEval_InitThreads
}

typedef void sigaction_handler_t(int, siginfo_t *, void *);
typedef sigaction_handler_t * sigaction_handler;

static PyObject * dnsig_register(PyObject *self, PyObject *args){
    int signum;
    PyObject *handler;
    if(!PyArg_ParseTuple(args, "iO", &signum, &handler))
        return NULL;
    printf("%d, %p/n", signum, handler);
    Py_XINCREF(handler);         /* Add a reference to new callback */
    //Py_XDECREF(current_handler);  /* Dispose of previous callback */
    current_handler = handler;

    struct sigaction action;
    //action.sa_sigaction=(sigaction_handler)handler;
    action.sa_sigaction = default_handler;
    sigemptyset(&action.sa_mask);
    action.sa_flags = SA_SIGINFO;
    sigaction(signum, &action, NULL);
   
    Py_INCREF(Py_None);
    return Py_None;
}

static PyMethodDef dnsigMethods[]={
{"register", dnsig_register, METH_VARARGS, "register signal handler"},
{NULL, NULL}//, 0, NULL}
};

PyMODINIT_FUNC
initdnsig(void){
   
    (void)Py_InitModule("dnsig", dnsigMethods);
}

int main(int argc, char **argv){
 /* Pass argv[0] to the Python interpreter */
    Py_SetProgramName(argv[0]);

    /* Initialize the Python interpreter.  Required. */
    Py_Initialize();

    /* Add a static module */
    initdnsig();

    /* Define sys.argv.  It is up to the application if you
       want this; you can also let it undefined (since the Python
       code is generally not a main program it has no business
       touching sys.argv...) */
    PySys_SetArgv(argc, argv);

    /* Do some application specific code */
    printf("Hello, brave new world/n/n");

    /* Execute some Python statements (in module __main__) */
    PyRun_SimpleString("import sys/n");
    PyRun_SimpleString("print sys.builtin_module_names/n");
    PyRun_SimpleString("print sys.modules.keys()/n");
    PyRun_SimpleString("print sys.executable/n");
    PyRun_SimpleString("print sys.argv/n");
    PyRun_SimpleString("import dm/n");

    /* Note that you can call any public function of the Python
       interpreter here, e.g. call_object(). */

    /* Some more application specific code */
    printf("/nGoodbye, cruel world/n");

    int fd;
    struct sigaction action;
    //action.sa_sigaction = handler;
    sigemptyset(&action.sa_mask);
    action.sa_flags = SA_SIGINFO;
//    sigaction(SIGRTMIN+1, &action, NULL);
   
    //fd = open("test", O_RDONLY);
    //fcntl(fd, F_SETSIG, SIGRTMIN+1);
    //fcntl(fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_MULTISHOT);

    //fd = open(".", O_RDONLY);
    //fcntl(fd, F_SETSIG, SIGRTMIN+1);
    //fcntl(fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_MULTISHOT);
    //while(1){
    //    pause();
    //    printf("got event on fd=%d/n", event_fd);
    //}

    Py_Exit(0);
}

具体的处理使用python来写，简单灵活多了。
#!/usr/bin/env py
#coding: UTF-8
#

import fcntl,os, signal, time, inspect, struct, traceback, dnsig;

def fmember(attr):
    return attr[0]=='f';

handlerCount = 0;
def handler(signum, frame):
    global handlerCount;
    handlerCount += 1;
    print "handle", handlerCount, time.time();
    #print inspect.getmembers(frame);

#def sighandler(signum, siginfo, ucontext):
def sighandler(signum, fd):
    print signum, fd;
    #print signum, str(siginfo), str(ucontext);
    #print struct.unpack('iiiiiilllllllllllll', str(siginfo));
    pass
    #

def dummy(signum):
    print 'dummy', signum;
    pass
    #

#set event handler for SIGIO, otherwise the program will terminate
#signal.signal(signal.SIGIO, lambda signum, stack:None);
#signal.signal(signal.SIGIO, handler);
#signal.sigaction(signal.SIGRTMIN+1, sighandler);
dnsig.register(signal.SIGRTMIN+1, sighandler);
#dnsig.register(signal.SIGRTMIN+1, dummy);

watchDir="test"

filedesc = os.open(watchDir, os.O_RDONLY);
print "fd %s, signum %s, sighandler: %s" %(filedesc, signal.SIGRTMIN+1, sighandler);


count =0;

flags=[fcntl.DN_CREATE, fcntl.DN_MODIFY, fcntl.DN_RENAME];
__innerFlags=reduce(lambda x, y: x | y, flags) | fcntl.DN_MULTISHOT;
#fcntl.DN_MULTISHOT;
try:
    try:
        #register watching service
        print 'register fcntl';
        fcntl.fcntl(filedesc, fcntl.F_SETSIG, signal.SIGRTMIN+1);
        fcntl.fcntl(filedesc,fcntl.F_NOTIFY, __innerFlags);
        while True:
            print 'start main loop'
            #block until signal received
            signal.pause();
            print 'signal recievd', time.time();
            #count+=1;
            #print "EVENT", count
    except KeyboardInterrupt:
        print "program exit now!"
    except:
        traceback.print_exec();
finally:
    os.close(filedesc);