add support for advisory locking ("lock" filesystem method)

Author: dzsekijo

example/xmp.py

@@ -10,6 +10,7 @@
 import os, sys
 from errno import *
 from stat import *
+import fcntl
 # some spaghetti to make it usable without fuse-py being installed
 for i in True, False:
     try:
@@ -202,6 +203,47 @@ def fgetattr(self):
         def ftruncate(self, len):
             self.file.truncate(len)
 
+        def lock(self, cmd, owner, **kw):
+            # The code here is much rather just a demonstration of the locking
+            # API than something which actually was seen to be useful.
+
+            # Advisory file locking is pretty messy in Unix, and the Python
+            # interface to this doesn't make it better.
+            # We can't do fcntl(2)/F_GETLK from Python in a platfrom independent
+            # way. The following implementation *might* work under Linux. 
+            #
+            # if cmd == fcntl.F_GETLK:
+            #     import struct
+            # 
+            #     lockdata = struct.pack('hhQQi', kw['l_type'], os.SEEK_SET,
+            #                            kw['l_start'], kw['l_len'], kw['l_pid'])
+            #     ld2 = fcntl.fcntl(self.fd, fcntl.F_GETLK, lockdata)
+            #     flockfields = ('l_type', 'l_whence', 'l_start', 'l_len', 'l_pid')
+            #     uld2 = struct.unpack('hhQQi', ld2)
+            #     res = {}
+            #     for i in xrange(len(uld2)):
+            #          res[flockfields[i]] = uld2[i]
+            #  
+            #     return fuse.Flock(**res)
+
+            # Convert fcntl-ish lock parameters to Python's weird
+            # lockf(3)/flock(2) medley locking API...
+            op = { fcntl.F_UNLCK : fcntl.LOCK_UN,
+                   fcntl.F_RDLCK : fcntl.LOCK_SH,
+                   fcntl.F_WRLCK : fcntl.LOCK_EX }[kw['l_type']]
+            if cmd == fcntl.F_GETLK:
+                return -EOPNOTSUPP
+            elif cmd == fcntl.F_SETLK:
+                if op != fcntl.LOCK_UN:
+                    op |= fcntl.LOCK_NB
+            elif cmd == fcntl.F_SETLKW:
+                pass
+            else:
+                return -EINVAL
+
+            fcntl.lockf(self.fd, op, kw['l_start'], kw['l_len'])
+
+
     def main(self, *a, **kw):
 
         self.file_class = self.XmpFile

fuse.py

@@ -381,7 +381,6 @@ class Stat(FuseStruct):
     pass
 
 
-
 class StatVfs(FuseStruct):
     """
     Auxiliary class which can be filled up statvfs attributes.
@@ -439,6 +438,18 @@ def __init__(self, name, **kw):
         FuseStruct.__init__(self, **kw)
 
 
+class Flock(FuseStruct):
+    """
+    Class for representing flock structures (cf. fcntl(3)).
+    
+    It makes sense to give values to the `l_type`, `l_start`,
+    `l_len`, `l_pid` attributes (`l_whence` is not used by
+    FUSE, see ``fuse.h``).
+    """
+ 
+    pass
+ 
+ 
 class FuseFileInfo(FuseStruct):
 
     def __init__(self, **kw):
@@ -502,6 +513,7 @@ def feature_needs(*feas):
             'has_ftruncate':  25,
             'has_fsinit':     ('has_init'),
             'has_fsdestroy':  ('has_destroy'),
+            'has_lock':       26,
             'has_init':       23,
             'has_destroy':    23,
             '*':              '!re:^\*$'}
@@ -594,7 +606,8 @@ class Fuse(object):
               'chown', 'truncate', 'utime', 'open', 'read', 'write', 'release',
               'statfs', 'fsync', 'create', 'opendir', 'releasedir', 'fsyncdir',
               'flush', 'fgetattr', 'ftruncate', 'getxattr', 'listxattr',
-              'setxattr', 'removexattr', 'access', 'fsinit', 'fsdestroy']
+              'setxattr', 'removexattr', 'access', 'lock', 'fsinit',
+              'fsdestroy']
 
     fusage = "%prog [mountpoint] [options]"
 
@@ -761,8 +774,8 @@ def __init__(self):
             class mpx(object):
                def __init__(self, name):
                    self.name = name
-               def __call__(self, *a):
-                   return getattr(a[-1], self.name)(*(a[1:-1]))
+               def __call__(self, *a, **kw):
+                   return getattr(a[-1], self.name)(*(a[1:-1]), **kw)
 
             self.proxyclass = mpx
             self.mdic = {}
@@ -791,7 +804,7 @@ def setter(self, xcls):
 
     Methproxy._add_class_type('file', ('open', 'create'),
                               ('read', 'write', 'fsync', 'release', 'flush',
-                               'fgetattr', 'ftruncate'))
+                               'fgetattr', 'ftruncate', 'lock'))
     Methproxy._add_class_type('dir', ('opendir',),
                               ('readdir', 'fsyncdir', 'releasedir'))
 

fuseparts/_fusemodule.c

@@ -11,6 +11,16 @@
     Copyright (C) 2006-2007  Csaba Henk  <csaba.henk@creo.hu> 
 */
 
+/* 
+ * Local Variables:
+ * indent-tabs-mode: t
+ * c-basic-offset: 8
+ * End:
+ * Changed by David McNab (david@rebirthing.co.nz) to work with recent pythons.
+ * Namely, replacing PyTuple_* with PySequence_*, and checking numerical values
+ * with both PyInt_Check and PyLong_Check.
+ */
+
 #ifndef FUSE_VERSION
 #ifndef FUSE_MAKE_VERSION
 #define FUSE_MAKE_VERSION(maj, min)  ((maj) * 10 + (min))
@@ -33,7 +43,8 @@ static PyObject *getattr_cb=NULL, *readlink_cb=NULL, *readdir_cb=NULL,
   *statfs_cb=NULL, *fsync_cb=NULL, *create_cb=NULL, *opendir_cb=NULL,
   *releasedir_cb=NULL, *fsyncdir_cb=NULL, *flush_cb=NULL, *ftruncate_cb=NULL,
   *fgetattr_cb=NULL, *getxattr_cb=NULL, *listxattr_cb=NULL, *setxattr_cb=NULL,
-  *removexattr_cb=NULL, *access_cb=NULL, *fsinit_cb=NULL, *fsdestroy_cb = NULL;
+  *removexattr_cb=NULL, *access_cb=NULL, *lock_cb = NULL, *fsinit_cb=NULL,
+  *fsdestroy_cb = NULL;
 
 static PyObject *Py_FuseError;
 static PyInterpreterState *interp;
@@ -161,16 +172,6 @@ fi_to_py(struct fuse_file_info *fi)
 #define fetchattr(st, attr)						\
 	fetchattr_nam(st, attr, #attr)
 
-/* 
- * Local Variables:
- * indent-tabs-mode: t
- * c-basic-offset: 8
- * End:
- * Changed by David McNab (david@rebirthing.co.nz) to work with recent pythons.
- * Namely, replacing PyTuple_* with PySequence_*, and checking numerical values
- * with both PyInt_Check and PyLong_Check.
- */
-
 #define fetchattr_soft(st, attr)					\
 	pytmp = PyObject_GetAttrString(v, #attr);			\
         if (pytmp == Py_None) {						\
@@ -181,6 +182,11 @@ fi_to_py(struct fuse_file_info *fi)
 		py2attr(st, attr);					\
 	}
 
+/*
+ * Following macros are only for getattr-alikes, we undef them after
+ * the getattr type functions.
+ */
+
 #define fetchattr_soft_d(st, attr, defa)				\
 	fetchattr_soft(st, attr) else st->attr = defa
 
@@ -243,7 +249,6 @@ fgetattr_func(const char *path, struct stat *st, struct fuse_file_info *fi)
 }
 #endif
 
-#undef fetchattr_soft
 #undef fetchattr_soft_d
 #undef FETCH_STAT_DATA
 
@@ -776,6 +781,55 @@ fsdestroy_func(void *param)
 }
 #endif
 
+static inline PyObject *
+lock_func_i(const char *path, struct fuse_file_info *fi, int cmd,
+            struct flock *lock)
+{
+	PyObject *pyargs, *pykw = NULL, *v = NULL;
+
+	pyargs =
+	fi_to_py(fi) ?
+	Py_BuildValue("(siKO)", path, cmd, fi->lock_owner, fi_to_py(fi)) :
+	Py_BuildValue("(siK)", path, cmd, fi->lock_owner); 
+	if (! pyargs)
+		goto out;
+
+	pykw = Py_BuildValue("{sisKsKsi}",
+	                     "l_type",  lock->l_type,
+	                     "l_start", lock->l_start,
+	                     "l_len",   lock->l_len,
+	                     "l_pid",   lock->l_pid);
+	if (! pykw)
+		goto out;
+
+	v = PyObject_Call(lock_cb, pyargs, pykw);
+
+out:
+	Py_XDECREF(pyargs);
+	Py_XDECREF(pykw);
+
+	return v;
+}
+
+static int
+lock_func(const char *path, struct fuse_file_info *fi, int cmd,
+          struct flock *lock)
+{
+	PyObject *pytmp;
+	unsigned long long ctmp;
+
+	PROLOGUE( lock_func_i(path, fi, cmd, lock) )
+
+	fetchattr_soft(lock, l_type);
+	fetchattr_soft(lock, l_start);
+	fetchattr_soft(lock, l_len);
+	fetchattr_soft(lock, l_pid);
+
+	ret = 0;
+
+	EPILOGUE
+}
+
 static int
 pyfuse_loop_mt(struct fuse *f)
 {
@@ -817,14 +871,14 @@ Fuse_main(PyObject *self, PyObject *args, PyObject *kw)
 		"open", "read", "write", "release", "statfs", "fsync",
 		"create", "opendir", "releasedir", "fsyncdir", "flush",
 	        "ftruncate", "fgetattr", "getxattr", "listxattr", "setxattr",
-	        "removexattr", "access", "fsinit", "fsdestroy", "fuse_args",
-		"multithreaded", NULL
+	        "removexattr", "access", "lock", "fsinit", "fsdestroy",
+		"fuse_args", "multithreaded", NULL
 	};
 
 	memset(&op, 0, sizeof(op));
 
 	if (!PyArg_ParseTupleAndKeywords(args, kw,
-	                                 "|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOi", 
+	                                 "|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOi", 
 	                                 kwlist, &getattr_cb, &readlink_cb,
 	                                 &readdir_cb, &mknod_cb, &mkdir_cb,
 	                                 &unlink_cb, &rmdir_cb, &symlink_cb,
@@ -837,7 +891,7 @@ Fuse_main(PyObject *self, PyObject *args, PyObject *kw)
 	                                 &flush_cb, &ftruncate_cb,
 	                                 &fgetattr_cb, &getxattr_cb,
 	                                 &listxattr_cb, &setxattr_cb,
-	                                 &removexattr_cb, &access_cb,
+	                                 &removexattr_cb, &access_cb, &lock_cb,
 	                                 &fsinit_cb, &fsdestroy_cb,
 	                                 &fargseq, &multithreaded))
 		return NULL;
@@ -890,6 +944,9 @@ Fuse_main(PyObject *self, PyObject *args, PyObject *kw)
 	DO_ONE_ATTR(access);
 	DO_ONE_ATTR(create);
 #endif
+#if FUSE_VERSION >= 26
+	DO_ONE_ATTR(lock);
+#endif
 #if FUSE_VERSION >= 23
 	DO_ONE_ATTR_AS(init, fsinit);
 	DO_ONE_ATTR_AS(destroy, fsdestroy);