llfuse-0.41.1/0000775000175000017500000000000012566230333014556 5ustar nikrationikratio00000000000000llfuse-0.41.1/Include/0000775000175000017500000000000012566230333016141 5ustar nikrationikratio00000000000000llfuse-0.41.1/Include/libc/0000775000175000017500000000000012566230333017052 5ustar nikrationikratio00000000000000llfuse-0.41.1/Include/libc/sys/0000775000175000017500000000000012566230333017670 5ustar nikrationikratio00000000000000llfuse-0.41.1/Include/libc/sys/__init__.py0000644000175000017500000000001512557224042021773 0ustar nikrationikratio00000000000000# Empty file llfuse-0.41.1/Include/libc/sys/stat.pxd0000664000175000017500000000130412557232665021370 0ustar nikrationikratio00000000000000''' stat.pxd This file contains Cython definitions for sys/stat.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from libc.sys.types cimport * cdef extern from "sys/stat.h" nogil: enum st_mode_constants: S_IFMT S_IFDIR struct stat: dev_t st_dev ino_t st_ino mode_t st_mode nlink_t st_nlink uid_t st_uid gid_t st_gid dev_t st_rdev off_t st_size blksize_t st_blksize blkcnt_t st_blocks time_t st_atime time_t st_mtime time_t st_ctime llfuse-0.41.1/Include/libc/sys/statvfs.pxd0000664000175000017500000000107512557232665022114 0ustar nikrationikratio00000000000000''' statvfs.pxd This file contains Cython definitions for sys/statvfs.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' cdef extern from "sys/statvfs.h" nogil: ctypedef int fsblkcnt_t ctypedef int fsfilcnt_t struct statvfs: int f_bsize int f_frsize fsblkcnt_t f_blocks fsblkcnt_t f_bfree fsblkcnt_t f_bavail fsfilcnt_t f_files fsfilcnt_t f_ffree fsfilcnt_t f_favail llfuse-0.41.1/Include/libc/sys/types.pxd0000664000175000017500000000104212557232665021560 0ustar nikrationikratio00000000000000''' types.pxd This file contains Cython definitions for sys/types.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' cdef extern from "sys/types.h" nogil: ctypedef int pid_t ctypedef int dev_t ctypedef int ino_t ctypedef int mode_t ctypedef int nlink_t ctypedef int uid_t ctypedef int gid_t ctypedef int dev_t ctypedef int off_t ctypedef int blksize_t ctypedef int blkcnt_t ctypedef int time_t llfuse-0.41.1/Include/libc/__init__.py0000644000175000017500000000001512557224042021155 0ustar nikrationikratio00000000000000# Empty file llfuse-0.41.1/Include/libc/dirent.pxd0000664000175000017500000000103612557232665021066 0ustar nikrationikratio00000000000000''' dirent.pxd This file contains Cython definitions for dirent.h and sys/types.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' cdef extern from "dirent.h" nogil: ctypedef struct DIR: pass cdef struct dirent: char* d_name dirent* readdir(DIR* dirp) int readdir_r(DIR *dirp, dirent *entry, dirent **result) cdef extern from "sys/types.h" nogil: DIR *opendir(char *name) int closedir(DIR* dirp) llfuse-0.41.1/Include/libc/errno.pxd0000664000175000017500000000061712557232665020732 0ustar nikrationikratio00000000000000''' errno.pxd This file contains Cython definitions for errno.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' cdef extern from "errno.h" nogil: enum: EDOM enum: EILSEQ enum: ERANGE enum: ENOATTR enum: ENOSYS enum: ENOENT enum: EEXIST enum: EIO int errno llfuse-0.41.1/Include/libc/xattr.pxd0000664000175000017500000000356112557232665020750 0ustar nikrationikratio00000000000000''' xattr.pxd This file contains Cython definitions for attr/xattr.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' IF TARGET_PLATFORM == 'darwin': cdef extern from "sys/xattr.h" nogil: int c_setxattr "setxattr" (char *path, char *name, void *value, int size, int flags, int options) int c_getxattr "getxattr" (char *path, char *name, void *value, int size, int position, int options) int XATTR_CREATE int XATTR_REPLACE int XATTR_NOFOLLOW int XATTR_NOSECURITY int XATTR_NODEFAULT cdef inline int setxattr (char *path, char *name, void *value, int size, int flags) nogil: return c_setxattr(path, name, value, size, flags, 0) cdef inline int getxattr (char *path, char *name, void *value, int size) nogil: return c_getxattr(path, name, value, size, 0, 0) ELIF TARGET_PLATFORM == 'freebsd': cdef extern from "sys/types.h": pass cdef extern from "sys/extattr.h" nogil: int extattr_set_file(char *path, int attrnamespace, char *attrname, void *data, int nbytes) int extattr_get_file(char *path, int attrnamespace, char *attrname, void *data, int nbytes) int EXTATTR_NAMESPACE_USER int EXTATTR_NAMESPACE_SYSTEM ELSE: cdef extern from "attr/xattr.h" nogil: int setxattr (char *path, char *name, void *value, int size, int flags) int getxattr (char *path, char *name, void *value, int size) int XATTR_CREATE int XATTR_REPLACE llfuse-0.41.1/Include/fuse_common.pxd0000664000175000017500000000164412557232665021207 0ustar nikrationikratio00000000000000''' fuse_common.pxd This file contains Cython definitions for fuse_common.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from fuse_opt cimport * from libc.stdint cimport uint64_t # Based on fuse sources, revision tag fuse_2_8_3 cdef extern from * nogil: # fuse_common.h should not be included struct fuse_file_info: int flags unsigned int direct_io unsigned int keep_cache unsigned int nonseekable uint64_t fh uint64_t lock_owner struct fuse_conn_info: pass struct fuse_session: pass struct fuse_chan: pass fuse_chan *fuse_mount(char *mountpoint, fuse_args *args) void fuse_unmount(char *mountpoint, fuse_chan *ch) int fuse_set_signal_handlers(fuse_session *se) void fuse_remove_signal_handlers(fuse_session *se) llfuse-0.41.1/Include/fuse_lowlevel.pxd0000664000175000017500000001525312557232665021551 0ustar nikrationikratio00000000000000''' fuse_lowlevel.pxd This file contains Cython definitions for fuse_lowlevel.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from fuse_common cimport * from libc.sys.stat cimport * from libc.sys.types cimport * from libc.sys.statvfs cimport * from libc.stdlib cimport const_char from libc.stdint cimport uint32_t # Based on fuse sources, revision tag fuse_2_8_3 cdef extern from "fuse_lowlevel.h" nogil: int FUSE_ROOT_ID ctypedef int fuse_ino_t ctypedef struct fuse_req: pass ctypedef fuse_req* fuse_req_t ctypedef int ulong_t "unsigned long" struct fuse_entry_param: fuse_ino_t ino unsigned long generation stat attr double attr_timeout double entry_timeout struct fuse_ctx: uid_t uid gid_t gid pid_t pid mode_t umask ctypedef fuse_ctx const_fuse_ctx "const struct fuse_ctx" int FUSE_SET_ATTR_MODE int FUSE_SET_ATTR_UID int FUSE_SET_ATTR_GID int FUSE_SET_ATTR_SIZE int FUSE_SET_ATTR_ATIME int FUSE_SET_ATTR_MTIME int FUSE_SET_ATTR_ATIME_NOW int FUSE_SET_ATTR_MTIME_NOW IF TARGET_PLATFORM == 'darwin': ctypedef void(*setxattr_fn_t)(fuse_req_t req, fuse_ino_t ino, const_char *name, const_char *value, size_t size, int flags, uint32_t position) ctypedef void(*getxattr_fn_t)(fuse_req_t req, fuse_ino_t ino, const_char *name, size_t size, uint32_t position) ELSE: ctypedef void(*setxattr_fn_t)(fuse_req_t req, fuse_ino_t ino, const_char *name, const_char *value, size_t size, int flags) ctypedef void(*getxattr_fn_t)(fuse_req_t req, fuse_ino_t ino, const_char *name, size_t size) struct fuse_lowlevel_ops: void (*init) (void *userdata, fuse_conn_info *conn) void (*destroy) (void *userdata) void (*lookup) (fuse_req_t req, fuse_ino_t parent, const_char *name) void (*forget) (fuse_req_t req, fuse_ino_t ino, ulong_t nlookup) void (*getattr) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*setattr) (fuse_req_t req, fuse_ino_t ino, stat *attr, int to_set, fuse_file_info *fi) void (*readlink) (fuse_req_t req, fuse_ino_t ino) void (*mknod) (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode, dev_t rdev) void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode) void (*unlink) (fuse_req_t req, fuse_ino_t parent, const_char *name) void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const_char *name) void (*symlink) (fuse_req_t req, const_char *link, fuse_ino_t parent, const_char *name) void (*rename) (fuse_req_t req, fuse_ino_t parent, const_char *name, fuse_ino_t newparent, const_char *newname) void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, const_char *newname) void (*open) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi) void (*write) (fuse_req_t req, fuse_ino_t ino, const_char *buf, size_t size, off_t off, fuse_file_info *fi) void (*flush) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*release) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi) void (*opendir) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi) void (*releasedir) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi) void (*statfs) (fuse_req_t req, fuse_ino_t ino) setxattr_fn_t setxattr getxattr_fn_t getxattr void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size) void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const_char *name) void (*access) (fuse_req_t req, fuse_ino_t ino, int mask) void (*create) (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode, fuse_file_info *fi) int fuse_reply_err(fuse_req_t req, int err) void fuse_reply_none(fuse_req_t req) int fuse_reply_entry(fuse_req_t req, fuse_entry_param *e) int fuse_reply_create(fuse_req_t req, fuse_entry_param *e, fuse_file_info *fi) int fuse_reply_attr(fuse_req_t req, stat *attr, double attr_timeout) int fuse_reply_readlink(fuse_req_t req, const_char *link) int fuse_reply_open(fuse_req_t req, fuse_file_info *fi) int fuse_reply_write(fuse_req_t req, size_t count) int fuse_reply_buf(fuse_req_t req, const_char *buf, size_t size) int fuse_reply_statfs(fuse_req_t req, statvfs *stbuf) int fuse_reply_xattr(fuse_req_t req, size_t count) size_t fuse_add_direntry(fuse_req_t req, const_char *buf, size_t bufsize, const_char *name, stat *stbuf, off_t off) int fuse_lowlevel_notify_inval_inode(fuse_chan *ch, fuse_ino_t ino, off_t off, off_t len) int fuse_lowlevel_notify_inval_entry(fuse_chan *ch, fuse_ino_t parent, const_char *name, size_t namelen) void *fuse_req_userdata(fuse_req_t req) fuse_ctx *fuse_req_ctx(fuse_req_t req) int fuse_req_getgroups(fuse_req_t req, size_t size, gid_t list[]) fuse_session *fuse_lowlevel_new(fuse_args *args, fuse_lowlevel_ops *op, size_t op_size, void *userdata) struct fuse_session_ops: pass fuse_session *fuse_session_new(fuse_session_ops *op, void *data) void fuse_session_add_chan(fuse_session *se, fuse_chan *ch) void fuse_session_remove_chan(fuse_chan *ch) void fuse_session_destroy(fuse_session *se) int fuse_session_loop(fuse_session *se) int fuse_session_loop_mt(fuse_session *se) void fuse_chan_destroy(fuse_chan *ch) llfuse-0.41.1/Include/fuse_opt.pxd0000664000175000017500000000060712557232665020517 0ustar nikrationikratio00000000000000''' fuse_opt.pxd This file contains Cython definitions for fuse_opt.h Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' # Based on fuse sources, revision tag fuse_2_8_3 cdef extern from "fuse_opt.h" nogil: struct fuse_args: int argc char **argv int allocated llfuse-0.41.1/doc/0000775000175000017500000000000012566230333015323 5ustar nikrationikratio00000000000000llfuse-0.41.1/examples/0000775000175000017500000000000012566230333016374 5ustar nikrationikratio00000000000000llfuse-0.41.1/examples/lltest.py0000775000175000017500000000760712566222351020273 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' lltest.py - Example file system for Python-LLFUSE. This program presents a static file system containing a single file. It is compatible with both Python 2.x and 3.x. Based on an example from Gerion Entrup. Copyright © 2015 Nikolaus Rath Copyright © 2015 Gerion Entrup. This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from __future__ import division, print_function, absolute_import import os import sys # We are running from the Python-LLFUSE source directory, put it # into the Python path. basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..')) if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'llfuse'))): sys.path.append(os.path.join(basedir, 'src')) from argparse import ArgumentParser import stat import logging import errno import llfuse log = logging.getLogger(__name__) class TestFs(llfuse.Operations): def __init__(self): super(TestFs, self).__init__() self.hello_name = b"message" self.hello_inode = llfuse.ROOT_INODE+1 self.hello_data = b"hello world\n" def getattr(self, inode): entry = llfuse.EntryAttributes() if inode == llfuse.ROOT_INODE: entry.st_mode = (stat.S_IFDIR | 0o755) entry.st_size = 0 elif inode == self.hello_inode: entry.st_mode = (stat.S_IFREG | 0o644) entry.st_size = len(self.hello_data) else: raise llfuse.FUSEError(errno.ENOENT) stamp = 1438467123.985654 entry.st_atime = stamp entry.st_ctime = stamp entry.st_mtime = stamp entry.st_gid = os.getgid() entry.st_uid = os.getuid() entry.st_ino = inode return entry def lookup(self, parent_inode, name): if parent_inode != llfuse.ROOT_INODE or name != self.hello_name: raise llfuse.FUSEError(errno.ENOENT) return self.getattr(self.hello_inode) def opendir(self, inode): if inode != llfuse.ROOT_INODE: raise llfuse.FUSEError(errno.ENOENT) return inode def readdir(self, fh, off): assert fh == llfuse.ROOT_INODE # only one entry if off == 0: yield (self.hello_name, self.getattr(self.hello_inode), 1) def open(self, inode, flags): if inode != self.hello_inode: raise llfuse.FUSEError(errno.ENOENT) if flags & os.O_RDWR or flags & os.O_WRONLY: raise llfuse.FUSEError(errno.EPERM) return inode def read(self, fh, off, size): assert fh == self.hello_inode return self.hello_data[off:off+size] def init_logging(debug=False): formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: ' '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S") handler = logging.StreamHandler() handler.setFormatter(formatter) root_logger = logging.getLogger() if debug: handler.setLevel(logging.DEBUG) root_logger.setLevel(logging.DEBUG) else: handler.setLevel(logging.INFO) root_logger.setLevel(logging.INFO) root_logger.addHandler(handler) def parse_args(): '''Parse command line''' parser = ArgumentParser() parser.add_argument('mountpoint', type=str, help='Where to mount the file system') parser.add_argument('--debug', action='store_true', default=False, help='Enable debugging output') return parser.parse_args() def main(): options = parse_args() init_logging(options.debug) testfs = TestFs() llfuse.init(testfs, options.mountpoint, [ 'fsname=lltest' ]) try: llfuse.main(single=True) except: llfuse.close(unmount=False) raise llfuse.close() if __name__ == '__main__': main() llfuse-0.41.1/examples/passthroughfs.py0000775000175000017500000003272512566222351021663 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 ''' passthroughfs.py - Example file system for Python-LLFUSE This file system mirrors the contents of a specified directory tree. It requires Python 3.3 (since Python 2.x does not support the follow_symlinks parameters for os.* functions). Caveats: * Inode generation numbers are not passed through but set to zero. * Block size (st_blksize) and number of allocated blocks (st_blocks) are not passed through. * Performance for large directories is not good, because the directory is always read completely. * There may be a way to break-out of the directory tree. * The readdir implementation is not fully POSIX compliant. If a directory contains hardlinks and is modified during a readdir call, readdir() may return some of the hardlinked files twice or omit them completely. * If you delete or rename files in the underlying file system, the passthrough file system will get confused. Copyright © Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' import os import sys # We are running from the Python-LLFUSE source directory, put it # into the Python path. basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..')) if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'llfuse'))): sys.path.append(os.path.join(basedir, 'src')) import llfuse from argparse import ArgumentParser import errno import logging import stat as stat_m from llfuse import FUSEError from os import fsencode, fsdecode from collections import defaultdict log = logging.getLogger(__name__) class Operations(llfuse.Operations): def __init__(self, source): super().__init__() self._inode_path_map = { llfuse.ROOT_INODE: source } self._lookup_cnt = defaultdict(lambda : 0) self._fd_inode_map = dict() self._inode_fd_map = dict() self._fd_open_count = dict() def _inode_to_path(self, inode): try: val = self._inode_path_map[inode] except KeyError: raise FUSEError(errno.ENOENT) if isinstance(val, set): # In case of hardlinks, pick any path val = next(iter(val)) return val def _add_path(self, inode, path): log.debug('_add_path for %d, %s', inode, path) self._lookup_cnt[inode] += 1 # With hardlinks, one inode may map to multiple paths. if inode not in self._inode_path_map: self._inode_path_map[inode] = path return val = self._inode_path_map[inode] if isinstance(val, set): val.add(path) elif val != path: self._inode_path_map[inode] = { path, val } def forget(self, inode_list): for (inode, nlookup) in inode_list: if self._lookup_cnt[inode] > nlookup: self._lookup_cnt[inode] -= nlookup continue log.debug('forgetting about inode %d', inode) assert inode not in self._inode_fd_map del self._lookup_cnt[inode] try: del self._inode_path_map[inode] except KeyError: # may have been deleted pass def lookup(self, inode_p, name): name = fsdecode(name) log.debug('lookup for %s in %d', name, inode_p) path = os.path.join(self._inode_to_path(inode_p), name) attr = self.getattr_path(path) if name != '.' and name != '..': self._add_path(attr.st_ino, path) return attr def getattr(self, inode): return self.getattr_path(self._inode_to_path(inode)) def getattr_path(self, path): try: stat = os.lstat(path) except OSError as exc: raise FUSEError(exc.errno) entry = llfuse.EntryAttributes() for attr in ('st_ino', 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', 'st_size', 'st_atime', 'st_mtime', 'st_ctime'): setattr(entry, attr, getattr(stat, attr)) entry.generation = 0 entry.entry_timeout = 5 entry.attr_timeout = 5 entry.st_blksize = 512 entry.st_blocks = ((entry.st_size+entry.st_blksize-1) // entry.st_blksize) return entry def readlink(self, inode): path = self._inode_to_path(inode) try: target = os.readlink(path) except OSError as exc: raise FUSEError(exc.errno) return fsencode(target) def opendir(self, inode): return inode def readdir(self, inode, off): path = self._inode_to_path(inode) log.debug('reading %s', path) entries = [] for name in os.listdir(path): attr = self.getattr_path(os.path.join(path, name)) entries.append((attr.st_ino, name, attr)) log.debug('read %d entries, starting at %d', len(entries), off) # This is not fully posix compatible. If there are hardlinks # (two names with the same inode), we don't have a unique # offset to start in between them. Note that we cannot simply # count entries, because then we would skip over entries # (or return them more than once) if the number of directory # entries changes between two calls to readdir(). for (ino, name, attr) in sorted(entries): if ino <= off: continue yield (fsencode(name), attr, ino) def unlink(self, inode_p, name): name = fsdecode(name) parent = self._inode_to_path(inode_p) path = os.path.join(parent, name) try: inode = os.lstat(path).st_ino os.unlink(path) except OSError as exc: raise FUSEError(exc.errno) if inode in self._lookup_cnt: self._forget_path(inode, path) def rmdir(self, inode_p, name): name = fsdecode(name) parent = self._inode_to_path(inode_p) path = os.path.join(parent, name) try: inode = os.lstat(path).st_ino os.rmdir(path) except OSError as exc: raise FUSEError(exc.errno) if inode in self._lookup_cnt: self._forget_path(inode, path) def _forget_path(self, inode, path): log.debug('forget %s for %d', path, inode) val = self._inode_path_map[inode] if isinstance(val, set): val.remove(path) if len(val) == 1: self._inode_path_map[inode] = next(iter(val)) else: del self._inode_path_map[inode] def symlink(self, inode_p, name, target, ctx): name = fsdecode(name) target = fsdecode(target) parent = self._inode_to_path(inode_p) path = os.path.join(parent, name) try: os.symlink(target, path) except OSError as exc: raise FUSEError(exc.errno) stat = os.lstat(path) self._add_path(stat.st_ino, path) return self.getattr(stat.st_ino) def rename(self, inode_p_old, name_old, inode_p_new, name_new): name_old = fsdecode(name_old) name_new = fsdecode(name_new) parent_old = self._inode_to_path(inode_p_old) parent_new = self._inode_to_path(inode_p_new) path_old = os.path.join(parent_old, name_old) path_new = os.path.join(parent_new, name_new) try: os.rename(path_old, path_new) inode = os.lstat(path_new).st_ino except OSError as exc: raise FUSEError(exc.errno) if inode not in self._lookup_cnt: return val = self._inode_path_map[inode] if isinstance(val, set): assert len(val) > 1 set.add(path_new) set.remove(path_old) else: assert val == path_old self._inode_path_map[inode] = path_new def link(self, inode, new_inode_p, new_name): new_name = fsdecode(new_name) parent = self._inode_to_path(new_inode_p) path = os.path.join(parent, new_name) try: os.link(self._inode_to_path(inode), path, follow_symlinks=False) except OSError as exc: raise FUSEError(exc.errno) self._add_path(inode, path) return self.getattr(inode) def setattr(self, inode, attr): path = self._inode_to_path(inode) try: if attr.st_size is not None: os.truncate(path, attr.st_size) if attr.st_mode is not None: os.chmod(path, ~stat_m.S_IFMT & attr.st_mode, follow_symlinks=False) assert (attr.st_uid is None) == (attr.st_gid is None) if attr.st_uid is not None: os.chown(path, attr.st_uid, attr.st_gid, follow_symlinks=False) assert (attr.st_atime is None) == (attr.st_mtime is None) if attr.st_atime is not None: os.utime(path, None, follow_symlinks=False, ns=(attr.st_atime_ns, attr.st_mtime_ns)) except OSError as exc: raise FUSEError(exc.errno) return self.getattr(inode) def mknod(self, inode_p, name, mode, rdev, ctx): path = os.path.join(self._inode_to_path(inode_p), fsdecode(name)) try: os.mknod(path, mode=(mode & ~ctx.umask), device=rdev) os.chown(path, ctx.uid, ctx.gid) except OSError as exc: raise FUSEError(exc.errno) attr = self.getattr_path(path) self._add_path(attr.st_ino, path) return attr def mkdir(self, inode_p, name, mode, ctx): path = os.path.join(self._inode_to_path(inode_p), fsdecode(name)) try: os.mkdir(path, mode=(mode & ~ctx.umask)) os.chown(path, ctx.uid, ctx.gid) except OSError as exc: raise FUSEError(exc.errno) attr = self.getattr_path(path) self._add_path(attr.st_ino, path) return attr def statfs(self): stat_ = llfuse.StatvfsData() try: statfs = os.statvfs(self._inode_path_map[llfuse.ROOT_INODE]) except OSError as exc: raise FUSEError(exc.errno) for attr in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bavail', 'f_files', 'f_ffree', 'f_favail'): setattr(stat_, attr, getattr(statfs, attr)) return stat_ def open(self, inode, flags): if inode in self._inode_fd_map: fd = self._inode_fd_map[inode] self._fd_open_count[fd] += 1 return fd assert flags & os.O_CREAT == 0 try: fd = os.open(self._inode_to_path(inode), flags) except OSError as exc: raise FUSEError(exc.errno) self._inode_fd_map[inode] = fd self._fd_inode_map[fd] = inode self._fd_open_count[fd] = 1 return fd def create(self, inode_p, name, mode, flags, ctx): path = os.path.join(self._inode_to_path(inode_p), fsdecode(name)) try: fd = os.open(path, flags | os.O_CREAT | os.O_TRUNC) except OSError as exc: raise FUSEError(exc.errno) attr = self.getattr_path(path) self._add_path(attr.st_ino, path) self._inode_fd_map[attr.st_ino] = fd self._fd_inode_map[fd] = attr.st_ino self._fd_open_count[fd] = 1 return (fd, attr) def read(self, fd, offset, length): os.lseek(fd, offset, os.SEEK_SET) return os.read(fd, length) def write(self, fd, offset, buf): os.lseek(fd, offset, os.SEEK_SET) return os.write(fd, buf) def release(self, fd): if self._fd_open_count[fd] > 1: self._fd_open_count[fd] -= 1 return del self._fd_open_count[fd] inode = self._fd_inode_map[fd] del self._inode_fd_map[inode] del self._fd_inode_map[fd] try: os.close(fd) except OSError as exc: raise FUSEError(exc.errno) def init_logging(debug=False): formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: ' '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S") handler = logging.StreamHandler() handler.setFormatter(formatter) root_logger = logging.getLogger() if debug: handler.setLevel(logging.DEBUG) root_logger.setLevel(logging.DEBUG) else: handler.setLevel(logging.INFO) root_logger.setLevel(logging.INFO) root_logger.addHandler(handler) def parse_args(args): '''Parse command line''' parser = ArgumentParser() parser.add_argument('source', type=str, help='Directory tree to mirror') parser.add_argument('mountpoint', type=str, help='Where to mount the file system') parser.add_argument('--single', action='store_true', default=False, help='Run single threaded') parser.add_argument('--debug', action='store_true', default=False, help='Enable debugging output') return parser.parse_args(args) def main(): options = parse_args(sys.argv[1:]) init_logging(options.debug) operations = Operations(options.source) log.debug('Mounting...') llfuse.init(operations, options.mountpoint, [ 'fsname=passthroughfs', "nonempty", 'default_permissions' ]) try: log.debug('Entering main loop..') llfuse.main(options.single) except: llfuse.close(unmount=False) raise log.debug('Unmounting..') llfuse.close() if __name__ == '__main__': main() llfuse-0.41.1/examples/tmpfs.py0000755000175000017500000003554512566222351020115 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' tmpfs.py - Example file system for Python-LLFUSE. This file system stores all data in memory. It is compatible with both Python 2.x and 3.x. Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from __future__ import division, print_function, absolute_import import os import sys # We are running from the Python-LLFUSE source directory, put it # into the Python path. basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..')) if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'llfuse'))): sys.path.append(os.path.join(basedir, 'src')) import llfuse import errno import stat from time import time import sqlite3 import logging from collections import defaultdict from llfuse import FUSEError from argparse import ArgumentParser log = logging.getLogger() # For Python 2 + 3 compatibility if sys.version_info[0] == 2: def next(it): return it.next() else: buffer = memoryview class Operations(llfuse.Operations): '''An example filesystem that stores all data in memory This is a very simple implementation with terrible performance. Don't try to store significant amounts of data. Also, there are some other flaws that have not been fixed to keep the code easier to understand: * atime, mtime and ctime are not updated * generation numbers are not supported ''' def __init__(self): super(Operations, self).__init__() self.db = sqlite3.connect(':memory:') self.db.text_factory = str self.db.row_factory = sqlite3.Row self.cursor = self.db.cursor() self.inode_open_count = defaultdict(int) self.init_tables() def init_tables(self): '''Initialize file system tables''' self.cursor.execute(""" CREATE TABLE inodes ( id INTEGER PRIMARY KEY, uid INT NOT NULL, gid INT NOT NULL, mode INT NOT NULL, mtime_ns INT NOT NULL, atime_ns INT NOT NULL, ctime_ns INT NOT NULL, target BLOB(256) , size INT NOT NULL DEFAULT 0, rdev INT NOT NULL DEFAULT 0, data BLOB ) """) self.cursor.execute(""" CREATE TABLE contents ( rowid INTEGER PRIMARY KEY AUTOINCREMENT, name BLOB(256) NOT NULL, inode INT NOT NULL REFERENCES inodes(id), parent_inode INT NOT NULL REFERENCES inodes(id), UNIQUE (name, parent_inode) )""") # Insert root directory now_ns = int(time() * 1e9) self.cursor.execute("INSERT INTO inodes (id,mode,uid,gid,mtime_ns,atime_ns,ctime_ns) " "VALUES (?,?,?,?,?,?,?)", (llfuse.ROOT_INODE, stat.S_IFDIR | stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH, os.getuid(), os.getgid(), now_ns, now_ns, now_ns)) self.cursor.execute("INSERT INTO contents (name, parent_inode, inode) VALUES (?,?,?)", (b'..', llfuse.ROOT_INODE, llfuse.ROOT_INODE)) def get_row(self, *a, **kw): self.cursor.execute(*a, **kw) try: row = next(self.cursor) except StopIteration: raise NoSuchRowError() try: next(self.cursor) except StopIteration: pass else: raise NoUniqueValueError() return row def lookup(self, inode_p, name): if name == '.': inode = inode_p elif name == '..': inode = self.get_row("SELECT * FROM contents WHERE inode=?", (inode_p,))['parent_inode'] else: try: inode = self.get_row("SELECT * FROM contents WHERE name=? AND parent_inode=?", (name, inode_p))['inode'] except NoSuchRowError: raise(llfuse.FUSEError(errno.ENOENT)) return self.getattr(inode) def getattr(self, inode): row = self.get_row('SELECT * FROM inodes WHERE id=?', (inode,)) entry = llfuse.EntryAttributes() entry.st_ino = inode entry.generation = 0 entry.entry_timeout = 300 entry.attr_timeout = 300 entry.st_mode = row['mode'] entry.st_nlink = self.get_row("SELECT COUNT(inode) FROM contents WHERE inode=?", (inode,))[0] entry.st_uid = row['uid'] entry.st_gid = row['gid'] entry.st_rdev = row['rdev'] entry.st_size = row['size'] entry.st_blksize = 512 entry.st_blocks = 1 entry.st_atime_ns = row['atime_ns'] entry.st_mtime_ns = row['mtime_ns'] entry.st_ctime_ns = row['ctime_ns'] return entry def readlink(self, inode): return self.get_row('SELECT * FROM inodes WHERE id=?', (inode,))['target'] def opendir(self, inode): return inode def readdir(self, inode, off): if off == 0: off = -1 cursor2 = self.db.cursor() cursor2.execute("SELECT * FROM contents WHERE parent_inode=? " 'AND rowid > ? ORDER BY rowid', (inode, off)) for row in cursor2: yield (row['name'], self.getattr(row['inode']), row['rowid']) def unlink(self, inode_p, name): entry = self.lookup(inode_p, name) if stat.S_ISDIR(entry.st_mode): raise llfuse.FUSEError(errno.EISDIR) self._remove(inode_p, name, entry) def rmdir(self, inode_p, name): entry = self.lookup(inode_p, name) if not stat.S_ISDIR(entry.st_mode): raise llfuse.FUSEError(errno.ENOTDIR) self._remove(inode_p, name, entry) def _remove(self, inode_p, name, entry): if self.get_row("SELECT COUNT(inode) FROM contents WHERE parent_inode=?", (entry.st_ino,))[0] > 0: raise llfuse.FUSEError(errno.ENOTEMPTY) self.cursor.execute("DELETE FROM contents WHERE name=? AND parent_inode=?", (name, inode_p)) if entry.st_nlink == 1 and entry.st_ino not in self.inode_open_count: self.cursor.execute("DELETE FROM inodes WHERE id=?", (entry.st_ino,)) def symlink(self, inode_p, name, target, ctx): mode = (stat.S_IFLNK | stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IWOTH | stat.S_IXOTH) return self._create(inode_p, name, mode, ctx, target=target) def rename(self, inode_p_old, name_old, inode_p_new, name_new): entry_old = self.lookup(inode_p_old, name_old) try: entry_new = self.lookup(inode_p_new, name_new) except llfuse.FUSEError as exc: if exc.errno != errno.ENOENT: raise target_exists = False else: target_exists = True if target_exists: self._replace(inode_p_old, name_old, inode_p_new, name_new, entry_old, entry_new) else: self.cursor.execute("UPDATE contents SET name=?, parent_inode=? WHERE name=? " "AND parent_inode=?", (name_new, inode_p_new, name_old, inode_p_old)) def _replace(self, inode_p_old, name_old, inode_p_new, name_new, entry_old, entry_new): if self.get_row("SELECT COUNT(inode) FROM contents WHERE parent_inode=?", (entry_new.st_ino,))[0] > 0: raise llfuse.FUSEError(errno.ENOTEMPTY) self.cursor.execute("UPDATE contents SET inode=? WHERE name=? AND parent_inode=?", (entry_old.st_ino, name_new, inode_p_new)) self.db.execute('DELETE FROM contents WHERE name=? AND parent_inode=?', (name_old, inode_p_old)) if entry_new.st_nlink == 1 and entry_new.st_ino not in self.inode_open_count: self.cursor.execute("DELETE FROM inodes WHERE id=?", (entry_new.st_ino,)) def link(self, inode, new_inode_p, new_name): entry_p = self.getattr(new_inode_p) if entry_p.st_nlink == 0: log.warn('Attempted to create entry %s with unlinked parent %d', new_name, new_inode_p) raise FUSEError(errno.EINVAL) self.cursor.execute("INSERT INTO contents (name, inode, parent_inode) VALUES(?,?,?)", (new_name, inode, new_inode_p)) return self.getattr(inode) def setattr(self, inode, attr): if attr.st_size is not None: data = self.get_row('SELECT data FROM inodes WHERE id=?', (inode,))[0] if data is None: data = b'' if len(data) < attr.st_size: data = data + b'\0' * (attr.st_size - len(data)) else: data = data[:attr.st_size] self.cursor.execute('UPDATE inodes SET data=?, size=? WHERE id=?', (buffer(data), attr.st_size, inode)) if attr.st_mode is not None: self.cursor.execute('UPDATE inodes SET mode=? WHERE id=?', (attr.st_mode, inode)) if attr.st_uid is not None: self.cursor.execute('UPDATE inodes SET uid=? WHERE id=?', (attr.st_uid, inode)) if attr.st_gid is not None: self.cursor.execute('UPDATE inodes SET gid=? WHERE id=?', (attr.st_gid, inode)) if attr.st_rdev is not None: self.cursor.execute('UPDATE inodes SET rdev=? WHERE id=?', (attr.st_rdev, inode)) if attr.st_atime_ns is not None: self.cursor.execute('UPDATE inodes SET atime_ns=? WHERE id=?', (attr.st_atime_ns, inode)) if attr.st_mtime_ns is not None: self.cursor.execute('UPDATE inodes SET mtime_ns=? WHERE id=?', (attr.st_mtime_ns, inode)) if attr.st_ctime_ns is not None: self.cursor.execute('UPDATE inodes SET ctime_ns=? WHERE id=?', (attr.st_ctime_ns, inode)) return self.getattr(inode) def mknod(self, inode_p, name, mode, rdev, ctx): return self._create(inode_p, name, mode, ctx, rdev=rdev) def mkdir(self, inode_p, name, mode, ctx): return self._create(inode_p, name, mode, ctx) def statfs(self): stat_ = llfuse.StatvfsData() stat_.f_bsize = 512 stat_.f_frsize = 512 size = self.get_row('SELECT SUM(size) FROM inodes')[0] stat_.f_blocks = size // stat_.f_frsize stat_.f_bfree = max(size // stat_.f_frsize, 1024) stat_.f_bavail = stat_.f_bfree inodes = self.get_row('SELECT COUNT(id) FROM inodes')[0] stat_.f_files = inodes stat_.f_ffree = max(inodes , 100) stat_.f_favail = stat_.f_ffree return stat_ def open(self, inode, flags): # Yeah, unused arguments #pylint: disable=W0613 self.inode_open_count[inode] += 1 # Use inodes as a file handles return inode def access(self, inode, mode, ctx): # Yeah, could be a function and has unused arguments #pylint: disable=R0201,W0613 return True def create(self, inode_parent, name, mode, flags, ctx): #pylint: disable=W0612 entry = self._create(inode_parent, name, mode, ctx) self.inode_open_count[entry.st_ino] += 1 return (entry.st_ino, entry) def _create(self, inode_p, name, mode, ctx, rdev=0, target=None): if self.getattr(inode_p).st_nlink == 0: log.warn('Attempted to create entry %s with unlinked parent %d', name, inode_p) raise FUSEError(errno.EINVAL) now_ns = int(time() * 1e9) self.cursor.execute('INSERT INTO inodes (uid, gid, mode, mtime_ns, atime_ns, ' 'ctime_ns, target, rdev) VALUES(?, ?, ?, ?, ?, ?, ?, ?)', (ctx.uid, ctx.gid, mode, now_ns, now_ns, now_ns, target, rdev)) inode = self.cursor.lastrowid self.db.execute("INSERT INTO contents(name, inode, parent_inode) VALUES(?,?,?)", (name, inode, inode_p)) return self.getattr(inode) def read(self, fh, offset, length): data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0] if data is None: data = b'' return data[offset:offset+length] def write(self, fh, offset, buf): data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0] if data is None: data = b'' data = data[:offset] + buf + data[offset+len(buf):] self.cursor.execute('UPDATE inodes SET data=?, size=? WHERE id=?', (buffer(data), len(data), fh)) return len(buf) def release(self, fh): self.inode_open_count[fh] -= 1 if self.inode_open_count[fh] == 0: del self.inode_open_count[fh] if self.getattr(fh).st_nlink == 0: self.cursor.execute("DELETE FROM inodes WHERE id=?", (fh,)) class NoUniqueValueError(Exception): def __str__(self): return 'Query generated more than 1 result row' class NoSuchRowError(Exception): def __str__(self): return 'Query produced 0 result rows' def init_logging(debug=False): formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: ' '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S") handler = logging.StreamHandler() handler.setFormatter(formatter) root_logger = logging.getLogger() if debug: handler.setLevel(logging.DEBUG) root_logger.setLevel(logging.DEBUG) else: handler.setLevel(logging.INFO) root_logger.setLevel(logging.INFO) root_logger.addHandler(handler) def parse_args(): '''Parse command line''' parser = ArgumentParser() parser.add_argument('mountpoint', type=str, help='Where to mount the file system') parser.add_argument('--debug', action='store_true', default=False, help='Enable debugging output') return parser.parse_args() if __name__ == '__main__': options = parse_args() init_logging(options.debug) operations = Operations() llfuse.init(operations, options.mountpoint, [ 'fsname=tmpfs', "nonempty" ]) # sqlite3 does not support multithreading try: llfuse.main(single=True) except: llfuse.close(unmount=False) raise llfuse.close() llfuse-0.41.1/rst/0000775000175000017500000000000012566230333015366 5ustar nikrationikratio00000000000000llfuse-0.41.1/rst/_static/0000775000175000017500000000000012566230333017014 5ustar nikrationikratio00000000000000llfuse-0.41.1/rst/_static/.placeholder0000644000175000017500000000000012343216623021262 0ustar nikrationikratio00000000000000llfuse-0.41.1/rst/_templates/0000775000175000017500000000000012566230333017523 5ustar nikrationikratio00000000000000llfuse-0.41.1/rst/_templates/localtoc.html0000644000175000017500000000013512343216623022205 0ustar nikrationikratio00000000000000

{{ _('Table Of Contents') }}

{{ toctree() }} llfuse-0.41.1/rst/about.rst0000644000175000017500000000006112557224042017225 0ustar nikrationikratio00000000000000.. -*- mode: rst -*- .. include:: ../README.rst llfuse-0.41.1/rst/conf.py0000664000175000017500000001505012557232665016700 0ustar nikrationikratio00000000000000# -*- coding: utf-8 -*- # # Python-LLFUSE documentation build configuration file, created by # sphinx-quickstart on Sat Oct 16 14:14:40 2010. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.append(os.path.abspath('.')) #pylint: disable-all #@PydevCodeAnalysisIgnore # -- General configuration ----------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx_cython' ] # Link to Python standard library intersphinx_mapping = {'python': ('http://docs.python.org/3/', None) } # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' autodoc_docstring_signature = True # The encoding of source files. source_encoding = 'utf-8' # The master toctree document. master_doc = 'index' # Warn about unresolved references nitpicky = True # General information about the project. project = u'Python-LLFUSE' copyright = u'2010-2015, Nikolaus Rath' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '1.0' # The full version, including alpha/beta/rc tags. release = '1.0' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. unused_docs = [ 'about' ] # List of directories, relative to source directory, that shouldn't be searched # for source files. exclude_trees = [] # The reST default role (used for this markup: `text`) to use for all documents. default_role = 'py:obj' primary_domain = 'py' # If true, '()' will be appended to :func: etc. cross-reference text. add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' #pygments_style = 'colorful' highlight_language = 'python' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. html_theme = 'default' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. html_use_modindex = False # If false, no index is generated. html_use_index = True # If true, the index is split into individual pages for each letter. html_split_index = False # If true, links to the reST sources are added to the pages. html_show_sourcelink = False # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = 'llfusedoc' # -- Options for LaTeX output -------------------------------------------------- # The paper size ('letter' or 'a4'). #latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). #latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'llfuse.tex', u'Python-LLFUSE Documentation', u'Nikolaus Rath', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # Additional stuff for the LaTeX preamble. #latex_preamble = '' # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_use_modindex = True llfuse-0.41.1/rst/data.rst0000664000175000017500000000404312557232665017044 0ustar nikrationikratio00000000000000================= Data Structures ================= .. currentmodule:: llfuse .. py:data:: ENOATTR This errorcode is unfortunately missing in the `errno` module, so it is provided by Python-LLFUSE instead. .. py:data:: ROOT_INODE The inode of the root directory, i.e. the mount point of the file system. .. autoexception:: FUSEError .. autoclass:: RequestContext .. attribute:: pid .. attribute:: uid .. attribute:: gid .. attribute:: umask .. autoclass:: StatvfsData .. attribute:: f_bsize .. attribute:: f_frsize .. attribute:: f_blocks .. attribute:: f_bfree .. attribute:: f_bavail .. attribute:: f_files .. attribute:: f_ffree .. attribute:: f_favail .. autoclass:: EntryAttributes .. attribute:: st_ino .. attribute:: generation The inode generation number. .. attribute:: entry_timeout Validity timeout (in seconds) for the name of the directory entry .. attribute:: attr_timeout Validity timeout (in seconds) for the attributes .. attribute:: st_mode .. attribute:: st_nlink .. attribute:: st_uid .. attribute:: st_gid .. attribute:: st_rdev .. attribute:: st_size .. attribute:: st_blksize .. attribute:: st_blocks .. attribute:: st_atime Time of access time in seconds. Floating point numbers may be used. .. attribute:: st_ctime Time of last status change in seconds. Floating point numbers may be used. .. attribute:: st_mtime Time of last modification in seconds. Floating point numbers may be used. .. attribute:: st_atime_ns Time of last access in nanoseconds. Only integer values may be used. If specified, takes precedence over `st_atime`. .. attribute:: st_ctime_ns Time of last status change in nanoseconds. Only integer values may be used. If specified, takes precedence over `st_ctime`. .. attribute:: st_mtime_ns Time of last modification in nanoseconds. Only integer values may be used. If specified, takes precedence over `st_mtime`. llfuse-0.41.1/rst/example.rst0000664000175000017500000000052612557232665017570 0ustar nikrationikratio00000000000000.. _example file system: ===================== Example File System ===================== The following is an example of a very simple in-memry file system based on Python-LLFUSE (this example is also included in the Python-LLFUSE tarball as :file:`examples/tmpfs.py`). .. literalinclude:: ../examples/tmpfs.py :linenos: :lines: 12- llfuse-0.41.1/rst/fuse_api.rst0000664000175000017500000000057212557224042017717 0ustar nikrationikratio00000000000000==================== FUSE API Functions ==================== .. currentmodule:: llfuse .. autofunction:: init .. autofunction:: main .. autofunction:: close .. autofunction:: setxattr .. autofunction:: getxattr .. autofunction:: listdir .. autofunction:: invalidate_inode .. autofunction:: invalidate_entry .. autofunction:: get_ino_t_bits .. autofunction:: get_off_t_bits llfuse-0.41.1/rst/getting_started.rst0000664000175000017500000000134412557232665021323 0ustar nikrationikratio00000000000000.. _getting_started: ================= Getting started ================= A file system is implemented by subclassing the `llfuse.Operations` class and implementing the various request handlers. An instance of the this class must then be passed to `llfuse.init` to mount the file system. To enter the request handling loop, run `llfuse.main`. This function will return when the file system should be unmounted again, which is done by calling `llfuse.close`. For easier debugging, it is strongly recommended that applications using Python-LLFUSE also make use of the faulthandler_ module. It is probably a good idea to look at the :ref:`example file system` as well. .. _faulthandler: http://docs.python.org/3/library/faulthandler.html llfuse-0.41.1/rst/index.rst0000664000175000017500000000060412557232665017241 0ustar nikrationikratio00000000000000============================= Python-LLFUSE Documentation ============================= .. include:: about.rst Table of Contents ----------------- .. module:: llfuse .. toctree:: :maxdepth: 1 install.rst getting_started.rst fuse_api.rst data.rst lock.rst operations.rst example.rst Indices and tables ------------------ * :ref:`genindex` * :ref:`search` llfuse-0.41.1/rst/install.rst0000664000175000017500000000432112566222351017567 0ustar nikrationikratio00000000000000========================== Installing Python-LLFUSE ========================== .. highlight:: sh Dependencies ============ In order to build and run Python-LLFUSE you need the following software: * Linux, FreeBSD, NetBSD or MacOS X system * Python_ 2.6 or newer (including Python 3.x), installed with development headers * The `setuptools`_ Python module, version 1.0 or newer. * the `pkg-config`_ tool * the `attr`_ library * A C compiler (only for building) When using Linux, you also need: * Kernel 2.6.9 or newer. Starting with kernel 2.6.26 you will get significantly better write performance, so under Linux you should actually use *2.6.26 or newer whenever possible*. * Version 2.8.0 or newer of the FUSE_ library, including development headers (typically distributions provide them in a *libfuse-devel* or *libfuse-dev* package). In case of FreeBSD and NetBSD you will need: * The FUSE4BSD_ kernel module. For OS-X, you need: * the FUSE4X_ package, version 0.9.1 or newer. Stable releases =============== Python-LLFUSE can be installed like any other Python extension. Make sure that you have all necessary dependencies installed (when installing packages from a distribution, make sure to also install the corresponding *-dev* or *-devel* development packages), then download and extract the Python-LLFUSE tarball and run :: sudo python setup.py install or :: python setup.py install --user Development Version =================== If you have checked out the unstable development version from the Mercurial repository, a bit more effort is required. You need to also have Cython_ (0.16 or newer) and Sphinx_ (1.1 or newer) installed, and the necessary commands are:: python setup.py build_cython python setup.py build_ext --inplace python setup.py build_sphinx python setup.py install .. _Cython: http://www.cython.org/ .. _Sphinx: http://sphinx.pocoo.org/ .. _Python: http://www.python.org/ .. _FUSE: http://fuse.sourceforge.net/ .. _attr: http://savannah.nongnu.org/projects/attr/ .. _`pkg-config`: http://www.freedesktop.org/wiki/Software/pkg-config .. _FUSE4BSD: http://www.freshports.org/sysutils/fusefs-kmod/ .. _FUSE4X: http://fuse4x.org/ .. _setuptools: https://pypi.python.org/pypi/setuptools llfuse-0.41.1/rst/lock.rst0000664000175000017500000000400012557232665017054 0ustar nikrationikratio00000000000000================= The global lock ================= .. currentmodule:: llfuse Python-LLFUSE uses a global lock to synchronize concurrent requests. Since the GIL already enforces that Python threads do not run concurrently, this does not result in any additional performance penalties. However, the use of an explicit lock allows direct control over which Python thread is running at a given time. Request handlers will always be called with the global lock acquired. However, they may release the global lock for potentially time consuming operations (like network or disk I/O), or to give other threads a chance to run during longer computations. Non-request handling threads may acquire the global lock to ensure that the execution of a particular code block will not be interrupted by any request handlers. Obviously, any method that directly or indirectly releases the global lock must be prepared to be called again while it has released the lock. In addition, it (and all its callers) must not hold any prior locks, since this may lead to deadlocks when re-acquiring the global lock. For this reason it is crucial that every method that directly or indirectly releases the lock is explicitly marked as such. The global lock is controlled with the `lock` and `lock_released` attributes of the `llfuse` module: .. py:attribute:: lock_released Controls the global lock. This object can be used as a context manager for the ``with`` statement to execute a block of code with the global lock released. .. py:attribute:: lock Controls the global lock. This object can be used as a context manager for the ``with`` statement to execute a block of code with the global lock acquired. Note that this object resembles a ``threading.Lock`` instance but is an instance of the `llfuse.Lock` class which is quite different from ``threading.Lock``. The `lock` object has the following methods: .. class:: llfuse.Lock .. automethod:: Lock.acquire() .. automethod:: Lock.release .. automethod:: Lock.yield_ llfuse-0.41.1/rst/operations.rst0000664000175000017500000000030612557224042020302 0ustar nikrationikratio00000000000000================== Request Handlers ================== (You can use the :ref:`genindex` to directly jump to a specific handler). .. currentmodule:: llfuse .. autoclass:: Operations :members: llfuse-0.41.1/src/0000775000175000017500000000000012566230333015345 5ustar nikrationikratio00000000000000llfuse-0.41.1/src/llfuse/0000775000175000017500000000000012566230333016637 5ustar nikrationikratio00000000000000llfuse-0.41.1/src/llfuse/__init__.py0000664000175000017500000000056612557232665020771 0ustar nikrationikratio00000000000000# -*- coding: utf-8 -*- ''' __init__.py Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from __future__ import division, print_function, absolute_import from llfuse.pyapi import * from llfuse.capi import * # dunder needs explicit import from .capi import __version__ llfuse-0.41.1/src/llfuse/capi.c0000644000175000017500000000064212566230170017716 0ustar nikrationikratio00000000000000/* capi.c Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. */ #ifdef __gnu_linux__ #include "capi_linux.c" #elif __FreeBSD__ #include "capi_freebsd.c" #elif __NetBSD__ #include "capi_freebsd.c" #elif __APPLE__ && __MACH__ #include "capi_darwin.c" #else #error "Unable to determine system (Linux/FreeBSD/Darwin)" #endif llfuse-0.41.1/src/llfuse/capi.pyx0000644000175000017500000000571412566222352020324 0ustar nikrationikratio00000000000000''' capi.pxy Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' # Version is defined in setup.py cdef extern from *: char* LLFUSE_VERSION __version__ = LLFUSE_VERSION.decode('utf-8') ########### # C IMPORTS ########### from fuse_lowlevel cimport * from libc.sys.stat cimport stat as c_stat, S_IFMT, S_IFDIR from libc.sys.types cimport mode_t, dev_t, off_t from libc.stdint cimport uint32_t from libc.stdlib cimport const_char from libc cimport stdlib, string, errno, dirent, xattr from posix.unistd cimport getpid from posix.time cimport clock_gettime, CLOCK_REALTIME, timespec from cpython.bytes cimport (PyBytes_AsStringAndSize, PyBytes_FromStringAndSize, PyBytes_AsString, PyBytes_FromString) cimport cpython.exc from cpython.version cimport PY_MAJOR_VERSION ###################### # EXTERNAL DEFINITIONS ###################### cdef extern from "signal.h" nogil: int kill(pid_t pid, int sig) enum: SIGTERM # Include components written in plain C cdef extern from "lock.c" nogil: int acquire(double timeout) nogil int release() nogil int c_yield(int count) nogil int init_lock() nogil int EINVAL int EDEADLK int EPERM int EPROTO int ETIMEDOUT int ENOMSG cdef extern from "time.c" nogil: long GET_ATIME_NS(c_stat* buf) long GET_CTIME_NS(c_stat* buf) long GET_MTIME_NS(c_stat* buf) void SET_ATIME_NS(c_stat* buf, long val) void SET_CTIME_NS(c_stat* buf, long val) void SET_MTIME_NS(c_stat* buf, long val) cdef extern from "Python.h" nogil: void PyEval_InitThreads() cdef extern from "version.c": pass ################ # PYTHON IMPORTS ################ import os import logging import sys import os.path import threading from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes from collections import namedtuple if PY_MAJOR_VERSION < 3: from Queue import Queue str_t = bytes else: from queue import Queue str_t = str ################## # GLOBAL VARIABLES ################## log = logging.getLogger("llfuse") fse = sys.getfilesystemencoding() cdef object operations cdef object mountpoint_b cdef fuse_session* session = NULL cdef fuse_chan* channel = NULL cdef fuse_lowlevel_ops fuse_ops cdef object exc_info init_lock() lock = Lock.__new__(Lock) lock_released = NoLockManager.__new__(NoLockManager) _notify_queue = Queue(maxsize=1000) inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) # Exported for access from Python code ROOT_INODE = FUSE_ROOT_ID ENOATTR = errno.ENOATTR ####################### # FUSE REQUEST HANDLERS ####################### include "handlers.pxi" #################### # INTERNAL FUNCTIONS #################### include "misc.pxi" #################### # FUSE API FUNCTIONS #################### include "fuse_api.pxi" llfuse-0.41.1/src/llfuse/capi_darwin.c0000664000175000017500000534345012566230170021300 0ustar nikrationikratio00000000000000/* Generated by Cython 0.21.1 */ #define PY_SSIZE_T_CLEAN #ifndef CYTHON_USE_PYLONG_INTERNALS #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 0 #else #include "pyconfig.h" #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 1 #else #define CYTHON_USE_PYLONG_INTERNALS 0 #endif #endif #endif #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else #define CYTHON_ABI "0_21_1" #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #if PY_MAJOR_VERSION >= 3 #define Py_TPFLAGS_CHECKTYPES 0 #define Py_TPFLAGS_HAVE_INDEX 0 #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #if PY_VERSION_HEX < 0x030400a1 && !defined(Py_TPFLAGS_HAVE_FINALIZE) #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #else #define CYTHON_PEP393_ENABLED 0 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #define __Pyx_PyFrozenSet_Size(s) PyObject_Size(s) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #define __Pyx_PyFrozenSet_Size(s) PySet_Size(s) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #ifndef CYTHON_INLINE #if defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is a quiet NaN. */ float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #ifdef __cplusplus template void __Pyx_call_destructor(T* x) { x->~T(); } #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #define __PYX_HAVE__llfuse__capi #define __PYX_HAVE_API__llfuse__capi #include "fuse_opt.h" #include "stdint.h" #include "sys/types.h" #include "sys/stat.h" #include "sys/statvfs.h" #include "string.h" #include "stdlib.h" #include "fuse_lowlevel.h" #include "errno.h" #include "dirent.h" #include "sys/xattr.h" #include "unistd.h" #include "signal.h" #include "sys/time.h" #include "lock.c" #include "time.c" #include "version.c" #ifdef _OPENMP #include #endif /* _OPENMP */ #ifdef PYREX_WITHOUT_ASSERTIONS #define CYTHON_WITHOUT_ASSERTIONS #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ (sizeof(type) < sizeof(Py_ssize_t)) || \ (sizeof(type) > sizeof(Py_ssize_t) && \ likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX) && \ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ v == (type)PY_SSIZE_T_MIN))) || \ (sizeof(type) == sizeof(Py_ssize_t) && \ (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromUString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((const char*)s) #if PY_MAJOR_VERSION < 3 static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #else #define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen #endif #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) #define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_COMPILING_IN_CPYTHON #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static PyObject *__pyx_m; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "llfuse/handlers.pxi", "llfuse/misc.pxi", "llfuse/fuse_api.pxi", "llfuse/capi.pyx", }; /*--- Type declarations ---*/ struct __pyx_obj_6llfuse_4capi_Lock; struct __pyx_obj_6llfuse_4capi_NoLockManager; /* "src/llfuse/misc.pxi":185 * raise * * cdef class Lock: # <<<<<<<<<<<<<< * ''' * This is the class of lock itself as well as a context manager to */ struct __pyx_obj_6llfuse_4capi_Lock { PyObject_HEAD }; /* "src/llfuse/misc.pxi":278 * * * cdef class NoLockManager: # <<<<<<<<<<<<<< * '''Context manager to execute code while the global lock is released''' * */ struct __pyx_obj_6llfuse_4capi_NoLockManager { PyObject_HEAD }; #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil) \ if (acquire_gil) { \ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ PyGILState_Release(__pyx_gilstate_save); \ } else { \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil) \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext() \ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_XDECREF(tmp); \ } while (0) #define __Pyx_DECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_DECREF(tmp); \ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name); #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) { PyObject *res; PyTypeObject *tp = Py_TYPE(obj); #if PY_MAJOR_VERSION < 3 if (unlikely(PyInstance_Check(obj))) return __Pyx_PyObject_GetAttrStr(obj, attr_name); #endif res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #else #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback); static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); static CYTHON_INLINE int __Pyx_IterFinish(void); static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyString_Join __Pyx_PyBytes_Join #define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) #else #define __Pyx_PyString_Join PyUnicode_Join #define __Pyx_PyBaseString_Join PyUnicode_Join #endif #if CYTHON_COMPILING_IN_CPYTHON #if PY_MAJOR_VERSION < 3 #define __Pyx_PyBytes_Join _PyString_Join #else #define __Pyx_PyBytes_Join _PyBytes_Join #endif #else static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ const char* function_name); static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact); #include static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) : \ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) : \ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); typedef struct { int code_line; PyCodeObject* code_object; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value); static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value); static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *); static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *); static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *); static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *); static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *); static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *); static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *); static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *); static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *); static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *); static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *); static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *); static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value); static int __Pyx_check_binary_version(void); static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'fuse_opt' */ /* Module declarations from 'libc.stdint' */ /* Module declarations from 'fuse_common' */ /* Module declarations from 'libc.sys.types' */ /* Module declarations from 'libc.sys.stat' */ /* Module declarations from 'libc.sys.statvfs' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdlib' */ /* Module declarations from 'fuse_lowlevel' */ /* Module declarations from 'libc' */ /* Module declarations from 'libc.errno' */ /* Module declarations from 'libc.dirent' */ /* Module declarations from 'libc.xattr' */ static CYTHON_INLINE int __pyx_f_4libc_5xattr_setxattr(char *, char *, void *, int, int); /*proto*/ static CYTHON_INLINE int __pyx_f_4libc_5xattr_getxattr(char *, char *, void *, int); /*proto*/ /* Module declarations from 'posix.types' */ /* Module declarations from 'posix.unistd' */ /* Module declarations from 'posix.signal' */ /* Module declarations from 'posix.time' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.version' */ /* Module declarations from 'llfuse.capi' */ static PyTypeObject *__pyx_ptype_6llfuse_4capi_Lock = 0; static PyTypeObject *__pyx_ptype_6llfuse_4capi_NoLockManager = 0; static PyObject *__pyx_v_6llfuse_4capi_operations = 0; static PyObject *__pyx_v_6llfuse_4capi_mountpoint_b = 0; static struct fuse_session *__pyx_v_6llfuse_4capi_session; static struct fuse_chan *__pyx_v_6llfuse_4capi_channel; static struct fuse_lowlevel_ops __pyx_v_6llfuse_4capi_fuse_ops; static PyObject *__pyx_v_6llfuse_4capi_exc_info = 0; static void __pyx_f_6llfuse_4capi_fuse_init(void *, struct fuse_conn_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_destroy(void *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_lookup(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_forget(fuse_req_t, fuse_ino_t, unsigned long); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_getattr(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_setattr(fuse_req_t, fuse_ino_t, struct stat *, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_readlink(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_mknod(fuse_req_t, fuse_ino_t, const char *, mode_t, dev_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_mkdir(fuse_req_t, fuse_ino_t, const char *, mode_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_unlink(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_rmdir(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_symlink(fuse_req_t, const char *, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_rename(fuse_req_t, fuse_ino_t, const char *, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_link(fuse_req_t, fuse_ino_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_open(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_read(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_write(fuse_req_t, fuse_ino_t, const char *, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_flush(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_release(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_fsync(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_opendir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_readdir(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_releasedir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_fsyncdir(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_statfs(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_setxattr_darwin(fuse_req_t, fuse_ino_t, const char *, const char *, size_t, int, uint32_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_setxattr(fuse_req_t, fuse_ino_t, const char *, const char *, size_t, int); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_getxattr_darwin(fuse_req_t, fuse_ino_t, const char *, size_t, uint32_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_getxattr(fuse_req_t, fuse_ino_t, const char *, size_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_listxattr(fuse_req_t, fuse_ino_t, size_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_removexattr(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_access(fuse_req_t, fuse_ino_t, int); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_create(fuse_req_t, fuse_ino_t, const char *, mode_t, struct fuse_file_info *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_entry_param(PyObject *, struct fuse_entry_param *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_c_stat(PyObject *, struct stat *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_statvfs(PyObject *, struct statvfs *); /*proto*/ static int __pyx_f_6llfuse_4capi_handle_exc(char *, PyObject *, fuse_req_t); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_get_request_context(fuse_req_t); /*proto*/ static void __pyx_f_6llfuse_4capi_init_fuse_ops(void); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_make_fuse_args(PyObject *, struct fuse_args *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_str2bytes(PyObject *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_bytes2str(PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "llfuse.capi" int __pyx_module_is_main_llfuse__capi = 0; /* Implementation of 'llfuse.capi' */ static PyObject *__pyx_builtin_BaseException; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_OSError; static int __pyx_pf_6llfuse_4capi_4Lock___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_2acquire(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_timeout); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_4release(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_6yield_(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_count); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_8__enter__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_10__exit__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb); /* proto */ static int __pyx_pf_6llfuse_4capi_13NoLockManager___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_a); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi__notify_loop(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_2listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_6getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, int __pyx_v_size_guess, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_8init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_args); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_10main(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_single); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_12close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_14invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode, PyObject *__pyx_v_attr_only); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_16invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode_p, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_18get_ino_t_bits(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_20get_off_t_bits(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_tp_new_6llfuse_4capi_Lock(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6llfuse_4capi_NoLockManager(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static char __pyx_k_o[] = "-o"; static char __pyx_k_t[] = "t"; static char __pyx_k_os[] = "os"; static char __pyx_k__28[] = "\000"; static char __pyx_k__49[] = "."; static char __pyx_k__50[] = ".."; static char __pyx_k_buf[] = "buf"; static char __pyx_k_ent[] = "ent"; static char __pyx_k_fse[] = "fse"; static char __pyx_k_get[] = "get"; static char __pyx_k_gid[] = "gid"; static char __pyx_k_ino[] = "ino"; static char __pyx_k_len[] = "len_"; static char __pyx_k_log[] = "log"; static char __pyx_k_ops[] = "ops"; static char __pyx_k_pid[] = "pid"; static char __pyx_k_put[] = "put"; static char __pyx_k_req[] = "req"; static char __pyx_k_res[] = "res"; static char __pyx_k_ret[] = "ret"; static char __pyx_k_sys[] = "sys"; static char __pyx_k_tmp[] = "tmp"; static char __pyx_k_uid[] = "uid"; static char __pyx_k_args[] = "args"; static char __pyx_k_dirp[] = "dirp"; static char __pyx_k_exit[] = "__exit__"; static char __pyx_k_init[] = "init"; static char __pyx_k_join[] = "join"; static char __pyx_k_link[] = "link"; static char __pyx_k_lock[] = "lock"; static char __pyx_k_main[] = "__main__"; static char __pyx_k_name[] = "name"; static char __pyx_k_open[] = "open"; static char __pyx_k_path[] = "path"; static char __pyx_k_read[] = "read"; static char __pyx_k_test[] = "__test__"; static char __pyx_k_user[] = "user"; static char __pyx_k_Queue[] = "Queue"; static char __pyx_k_block[] = "block"; static char __pyx_k_close[] = "close"; static char __pyx_k_cname[] = "cname"; static char __pyx_k_count[] = "count"; static char __pyx_k_cpath[] = "cpath"; static char __pyx_k_debug[] = "debug"; static char __pyx_k_enter[] = "__enter__"; static char __pyx_k_errno[] = "errno"; static char __pyx_k_error[] = "error"; static char __pyx_k_flush[] = "flush"; static char __pyx_k_fsync[] = "fsync"; static char __pyx_k_inode[] = "inode"; static char __pyx_k_mkdir[] = "mkdir"; static char __pyx_k_mknod[] = "mknod"; static char __pyx_k_names[] = "names"; static char __pyx_k_queue[] = "queue"; static char __pyx_k_range[] = "range"; static char __pyx_k_rmdir[] = "rmdir"; static char __pyx_k_start[] = "start"; static char __pyx_k_str_t[] = "str_t"; static char __pyx_k_umask[] = "umask"; static char __pyx_k_value[] = "value"; static char __pyx_k_write[] = "write"; static char __pyx_k_Thread[] = "Thread"; static char __pyx_k_access[] = "access"; static char __pyx_k_create[] = "create"; static char __pyx_k_cvalue[] = "cvalue"; static char __pyx_k_daemon[] = "daemon"; static char __pyx_k_decode[] = "decode"; static char __pyx_k_encode[] = "encode"; static char __pyx_k_exc_tb[] = "exc_tb"; static char __pyx_k_f_args[] = "f_args"; static char __pyx_k_forget[] = "forget"; static char __pyx_k_import[] = "__import__"; static char __pyx_k_llfuse[] = "llfuse"; static char __pyx_k_lookup[] = "lookup"; static char __pyx_k_main_2[] = "main"; static char __pyx_k_name_b[] = "name_b"; static char __pyx_k_path_b[] = "path_b"; static char __pyx_k_rename[] = "rename"; static char __pyx_k_single[] = "single"; static char __pyx_k_st_gid[] = "st_gid"; static char __pyx_k_st_ino[] = "st_ino"; static char __pyx_k_st_uid[] = "st_uid"; static char __pyx_k_statfs[] = "statfs"; static char __pyx_k_system[] = "system"; static char __pyx_k_target[] = "target"; static char __pyx_k_unlink[] = "unlink"; static char __pyx_k_ENOATTR[] = "ENOATTR"; static char __pyx_k_OSError[] = "OSError"; static char __pyx_k_abspath[] = "abspath"; static char __pyx_k_acquire[] = "acquire"; static char __pyx_k_bufsize[] = "bufsize"; static char __pyx_k_destroy[] = "destroy"; static char __pyx_k_exc_val[] = "exc_val"; static char __pyx_k_f_bfree[] = "f_bfree"; static char __pyx_k_f_bsize[] = "f_bsize"; static char __pyx_k_f_ffree[] = "f_ffree"; static char __pyx_k_f_files[] = "f_files"; static char __pyx_k_getattr[] = "getattr"; static char __pyx_k_inode_p[] = "inode_p"; static char __pyx_k_listdir[] = "listdir"; static char __pyx_k_logging[] = "logging"; static char __pyx_k_maxsize[] = "maxsize"; static char __pyx_k_opendir[] = "opendir"; static char __pyx_k_os_path[] = "os.path"; static char __pyx_k_readdir[] = "readdir"; static char __pyx_k_release[] = "release"; static char __pyx_k_setattr[] = "setattr"; static char __pyx_k_st_mode[] = "st_mode"; static char __pyx_k_st_rdev[] = "st_rdev"; static char __pyx_k_st_size[] = "st_size"; static char __pyx_k_symlink[] = "symlink"; static char __pyx_k_timeout[] = "timeout"; static char __pyx_k_unmount[] = "unmount"; static char __pyx_k_version[] = "__version__"; static char __pyx_k_exc_info[] = "exc_info"; static char __pyx_k_exc_type[] = "exc_type"; static char __pyx_k_f_bavail[] = "f_bavail"; static char __pyx_k_f_blocks[] = "f_blocks"; static char __pyx_k_f_favail[] = "f_favail"; static char __pyx_k_f_frsize[] = "f_frsize"; static char __pyx_k_fsyncdir[] = "fsyncdir"; static char __pyx_k_getxattr[] = "getxattr"; static char __pyx_k_readlink[] = "readlink"; static char __pyx_k_setxattr[] = "setxattr"; static char __pyx_k_st_atime[] = "st_atime"; static char __pyx_k_st_ctime[] = "st_ctime"; static char __pyx_k_st_mtime[] = "st_mtime"; static char __pyx_k_st_nlink[] = "st_nlink"; static char __pyx_k_strerror[] = "strerror"; static char __pyx_k_us_ascii[] = "us-ascii"; static char __pyx_k_FUSEError[] = "FUSEError"; static char __pyx_k_TypeError[] = "TypeError"; static char __pyx_k_attr_only[] = "attr_only"; static char __pyx_k_enumerate[] = "enumerate"; static char __pyx_k_exception[] = "exception"; static char __pyx_k_getLogger[] = "getLogger"; static char __pyx_k_listxattr[] = "listxattr"; static char __pyx_k_namespace[] = "namespace"; static char __pyx_k_st_blocks[] = "st_blocks"; static char __pyx_k_threading[] = "threading"; static char __pyx_k_Operations[] = "Operations"; static char __pyx_k_ROOT_INODE[] = "ROOT_INODE"; static char __pyx_k_ValueError[] = "ValueError"; static char __pyx_k_generation[] = "generation"; static char __pyx_k_mountpoint[] = "mountpoint"; static char __pyx_k_namedtuple[] = "namedtuple"; static char __pyx_k_releasedir[] = "releasedir"; static char __pyx_k_size_guess[] = "size_guess"; static char __pyx_k_st_blksize[] = "st_blksize"; static char __pyx_k_stacktrace[] = "stacktrace"; static char __pyx_k_collections[] = "collections"; static char __pyx_k_llfuse_capi[] = "llfuse.capi"; static char __pyx_k_notify_loop[] = "_notify_loop"; static char __pyx_k_removexattr[] = "removexattr"; static char __pyx_k_st_atime_ns[] = "st_atime_ns"; static char __pyx_k_st_ctime_ns[] = "st_ctime_ns"; static char __pyx_k_st_mtime_ns[] = "st_mtime_ns"; static char __pyx_k_RuntimeError[] = "RuntimeError"; static char __pyx_k_attr_timeout[] = "attr_timeout"; static char __pyx_k_llfuse_pyapi[] = "llfuse.pyapi"; static char __pyx_k_notify_queue[] = "_notify_queue"; static char __pyx_k_BaseException[] = "BaseException"; static char __pyx_k_Python_LLFUSE[] = "Python-LLFUSE"; static char __pyx_k_entry_timeout[] = "entry_timeout"; static char __pyx_k_lock_released[] = "lock_released"; static char __pyx_k_RequestContext[] = "RequestContext"; static char __pyx_k_get_ino_t_bits[] = "get_ino_t_bits"; static char __pyx_k_get_off_t_bits[] = "get_off_t_bits"; static char __pyx_k_with_traceback[] = "with_traceback"; static char __pyx_k_EntryAttributes[] = "EntryAttributes"; static char __pyx_k_fuse_stacktrace[] = "fuse_stacktrace"; static char __pyx_k_inval_entry_req[] = "inval_entry_req"; static char __pyx_k_inval_inode_req[] = "inval_inode_req"; static char __pyx_k_surrogateescape[] = "surrogateescape"; static char __pyx_k_invalidate_entry[] = "invalidate_entry"; static char __pyx_k_invalidate_inode[] = "invalidate_inode"; static char __pyx_k_unknown_flag_s_o[] = "unknown flag(s): %o"; static char __pyx_k_fuse_mount_failed[] = "fuse_mount failed"; static char __pyx_k_Calling_fuse_mount[] = "Calling fuse_mount"; static char __pyx_k_Initializing_llfuse[] = "Initializing llfuse"; static char __pyx_k_Calling_fuse_unmount[] = "Calling fuse_unmount"; static char __pyx_k_Exception_after_kill[] = "Exception after kill:"; static char __pyx_k_Lock_not_initialized[] = "Lock not initialized"; static char __pyx_k_getfilesystemencoding[] = "getfilesystemencoding"; static char __pyx_k_Weird_request_received_r[] = "Weird request received: %r"; static char __pyx_k_fuse_lowlevel_new_failed[] = "fuse_lowlevel_new() failed"; static char __pyx_k_fuse_session_loop_failed[] = "fuse_session_loop failed"; static char __pyx_k_Calling_fuse_lowlevel_new[] = "Calling fuse_lowlevel_new"; static char __pyx_k_Calling_fuse_session_loop[] = "Calling fuse_session_loop"; static char __pyx_k_fuse_session_loop_mt_failed[] = "fuse_session_loop_mt() failed"; static char __pyx_k_Calling_fuse_session_destroy[] = "Calling fuse_session_destroy"; static char __pyx_k_Calling_fuse_session_loop_mt[] = "Calling fuse_session_loop_mt"; static char __pyx_k_Calling_fuse_session_add_chan[] = "Calling fuse_session_add_chan"; static char __pyx_k_Need_to_call_init_before_main[] = "Need to call init() before main()"; static char __pyx_k_Other_thread_didn_t_take_lock[] = "Other thread didn't take lock"; static char __pyx_k_You_should_not_instantiate_this[] = "You should not instantiate this class, use the provided instance instead."; static char __pyx_k_capi_pxy_Copyright_2013_Nikolau[] = "\ncapi.pxy\n\nCopyright \302\251 2013 Nikolaus Rath \n\nThis file is part of Python-LLFUSE. This work may be distributed under\nthe terms of the GNU LGPL.\n"; static char __pyx_k_fuse_getattr_fuse_reply__failed[] = "fuse_getattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_getxattr_non_zero_position[] = "fuse_getxattr(): non-zero position (%d) not supported"; static char __pyx_k_fuse_opendir_fuse_reply__failed[] = "fuse_opendir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_readdir_fuse_reply__failed[] = "fuse_readdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_release_fuse_reply__failed[] = "fuse_release(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_set_signal_handlers_failed[] = "fuse_set_signal_handlers() failed"; static char __pyx_k_fuse_setattr_fuse_reply__failed[] = "fuse_setattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_setxattr_non_zero_position[] = "fuse_setxattr(): non-zero position (%d) not supported"; static char __pyx_k_fuse_symlink_fuse_reply__failed[] = "fuse_symlink(): fuse_reply_* failed with %s"; static char __pyx_k_home_nikratio_in_progress_pytho[] = "/home/nikratio/in-progress/python-llfuse/src/llfuse/misc.pxi"; static char __pyx_k_mountpoint__argument_must_be_of[] = "*mountpoint_* argument must be of type str"; static char __pyx_k_name_argument_must_be_of_type_s[] = "*name* argument must be of type str"; static char __pyx_k_namespace_parameter_must_be_sys[] = "*namespace* parameter must be \"system\" or \"user\", not %s"; static char __pyx_k_path_argument_must_be_of_type_s[] = "*path* argument must be of type str"; static char __pyx_k_Calling_fuse_remove_signal_handl[] = "Calling fuse_remove_signal_handlers"; static char __pyx_k_Calling_fuse_session_remove_chan[] = "Calling fuse_session_remove_chan"; static char __pyx_k_Calling_fuse_set_signal_handlers[] = "Calling fuse_set_signal_handlers"; static char __pyx_k_Global_lock_cannot_be_acquired_m[] = "Global lock cannot be acquired more than once"; static char __pyx_k_Lock_can_only_be_released_by_the[] = "Lock can only be released by the holding thread"; static char __pyx_k_Lock_still_taken_after_receiving[] = "Lock still taken after receiving unlock notification"; static char __pyx_k_Terminated_main_loop_because_req[] = "Terminated main loop because request handler raised exception, re-raising.."; static char __pyx_k_fuse_access_fuse_reply__failed_w[] = "fuse_access(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_create_fuse_reply__failed_w[] = "fuse_create(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_flush_fuse_reply__failed_wi[] = "fuse_flush(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_fsync_fuse_reply__failed_wi[] = "fuse_fsync(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_fsyncdir_fuse_reply__failed[] = "fuse_fsyncdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_getxattr_fuse_reply__failed[] = "fuse_getxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_link_fuse_reply__failed_wit[] = "fuse_link(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_listxattr_fuse_reply__faile[] = "fuse_listxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_lookup_fuse_reply__failed_w[] = "fuse_lookup(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_mkdir_fuse_reply__failed_wi[] = "fuse_mkdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_mknod_fuse_reply__failed_wi[] = "fuse_mknod(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_options_must_be_of_type_str[] = "fuse options must be of type str"; static char __pyx_k_fuse_read_fuse_reply__failed_wit[] = "fuse_read(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_readlink_fuse_reply__failed[] = "fuse_readlink(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_releasedir_fuse_reply__fail[] = "fuse_releasedir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_removexattr_fuse_reply__fai[] = "fuse_removexattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_rename_fuse_reply__failed_w[] = "fuse_rename(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_rmdir_fuse_reply__failed_wi[] = "fuse_rmdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_setattr_clock_gettime_CLOCK[] = "fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s"; static char __pyx_k_fuse_setxattr_fuse_reply__failed[] = "fuse_setxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_setxattr_fuse_reply_err_fai[] = "fuse_setxattr(): fuse_reply_err failed with %s"; static char __pyx_k_fuse_statfs_fuse_reply__failed_w[] = "fuse_statfs(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_unlink_fuse_reply__failed_w[] = "fuse_unlink(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_write_fuse_reply_err_d_fail[] = "fuse_write(): fuse_reply_err(%d) failed with %s"; static char __pyx_k_fuse_write_fuse_reply_err_failed[] = "fuse_write(): fuse_reply_err failed with %s after exception"; static char __pyx_k_fuse_write_fuse_reply_write_fail[] = "fuse_write(): fuse_reply_write failed with %s"; static char __pyx_k_handler_raised_exception_sending[] = "handler raised exception, sending SIGTERM to self."; static char __pyx_k_home_nikratio_in_progress_pytho_2[] = "/home/nikratio/in-progress/python-llfuse/src/llfuse/fuse_api.pxi"; static PyObject *__pyx_n_s_BaseException; static PyObject *__pyx_kp_u_Calling_fuse_lowlevel_new; static PyObject *__pyx_kp_u_Calling_fuse_mount; static PyObject *__pyx_kp_u_Calling_fuse_remove_signal_handl; static PyObject *__pyx_kp_u_Calling_fuse_session_add_chan; static PyObject *__pyx_kp_u_Calling_fuse_session_destroy; static PyObject *__pyx_kp_u_Calling_fuse_session_loop; static PyObject *__pyx_kp_u_Calling_fuse_session_loop_mt; static PyObject *__pyx_kp_u_Calling_fuse_session_remove_chan; static PyObject *__pyx_kp_u_Calling_fuse_set_signal_handlers; static PyObject *__pyx_kp_u_Calling_fuse_unmount; static PyObject *__pyx_n_s_ENOATTR; static PyObject *__pyx_n_s_EntryAttributes; static PyObject *__pyx_kp_u_Exception_after_kill; static PyObject *__pyx_n_s_FUSEError; static PyObject *__pyx_kp_u_Global_lock_cannot_be_acquired_m; static PyObject *__pyx_kp_u_Initializing_llfuse; static PyObject *__pyx_kp_u_Lock_can_only_be_released_by_the; static PyObject *__pyx_kp_u_Lock_not_initialized; static PyObject *__pyx_kp_u_Lock_still_taken_after_receiving; static PyObject *__pyx_kp_u_Need_to_call_init_before_main; static PyObject *__pyx_n_s_OSError; static PyObject *__pyx_n_s_Operations; static PyObject *__pyx_kp_u_Other_thread_didn_t_take_lock; static PyObject *__pyx_kp_b_Python_LLFUSE; static PyObject *__pyx_n_s_Queue; static PyObject *__pyx_n_s_ROOT_INODE; static PyObject *__pyx_n_s_RequestContext; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_kp_u_Terminated_main_loop_because_req; static PyObject *__pyx_n_s_Thread; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_kp_u_Weird_request_received_r; static PyObject *__pyx_kp_u_You_should_not_instantiate_this; static PyObject *__pyx_kp_b__28; static PyObject *__pyx_n_s_abspath; static PyObject *__pyx_n_s_access; static PyObject *__pyx_n_s_acquire; static PyObject *__pyx_n_s_args; static PyObject *__pyx_n_s_attr_only; static PyObject *__pyx_n_u_attr_only; static PyObject *__pyx_n_s_attr_timeout; static PyObject *__pyx_n_s_block; static PyObject *__pyx_n_s_buf; static PyObject *__pyx_n_s_bufsize; static PyObject *__pyx_n_s_close; static PyObject *__pyx_n_s_cname; static PyObject *__pyx_n_s_collections; static PyObject *__pyx_n_s_count; static PyObject *__pyx_n_s_cpath; static PyObject *__pyx_n_s_create; static PyObject *__pyx_n_s_cvalue; static PyObject *__pyx_n_s_daemon; static PyObject *__pyx_n_s_debug; static PyObject *__pyx_n_s_decode; static PyObject *__pyx_n_s_destroy; static PyObject *__pyx_n_s_dirp; static PyObject *__pyx_n_s_encode; static PyObject *__pyx_n_s_ent; static PyObject *__pyx_n_s_enter; static PyObject *__pyx_n_s_entry_timeout; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_errno; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_exc_info; static PyObject *__pyx_n_s_exc_tb; static PyObject *__pyx_n_s_exc_type; static PyObject *__pyx_n_s_exc_val; static PyObject *__pyx_n_s_exception; static PyObject *__pyx_n_s_exit; static PyObject *__pyx_n_s_f_args; static PyObject *__pyx_n_s_f_bavail; static PyObject *__pyx_n_s_f_bfree; static PyObject *__pyx_n_s_f_blocks; static PyObject *__pyx_n_s_f_bsize; static PyObject *__pyx_n_s_f_favail; static PyObject *__pyx_n_s_f_ffree; static PyObject *__pyx_n_s_f_files; static PyObject *__pyx_n_s_f_frsize; static PyObject *__pyx_n_s_flush; static PyObject *__pyx_n_s_forget; static PyObject *__pyx_n_s_fse; static PyObject *__pyx_n_s_fsync; static PyObject *__pyx_n_s_fsyncdir; static PyObject *__pyx_kp_u_fuse_access_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_create_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_flush_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_getattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_getxattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_getxattr_non_zero_position; static PyObject *__pyx_kp_u_fuse_link_fuse_reply__failed_wit; static PyObject *__pyx_kp_u_fuse_listxattr_fuse_reply__faile; static PyObject *__pyx_kp_u_fuse_lookup_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_lowlevel_new_failed; static PyObject *__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_mount_failed; static PyObject *__pyx_kp_u_fuse_opendir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_options_must_be_of_type_str; static PyObject *__pyx_kp_u_fuse_read_fuse_reply__failed_wit; static PyObject *__pyx_kp_u_fuse_readdir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_readlink_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_release_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_releasedir_fuse_reply__fail; static PyObject *__pyx_kp_u_fuse_removexattr_fuse_reply__fai; static PyObject *__pyx_kp_u_fuse_rename_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_session_loop_failed; static PyObject *__pyx_kp_u_fuse_session_loop_mt_failed; static PyObject *__pyx_kp_u_fuse_set_signal_handlers_failed; static PyObject *__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK; static PyObject *__pyx_kp_u_fuse_setattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_setxattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_setxattr_fuse_reply_err_fai; static PyObject *__pyx_kp_u_fuse_setxattr_non_zero_position; static PyObject *__pyx_kp_u_fuse_statfs_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_symlink_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_unlink_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_err_d_fail; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_err_failed; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_write_fail; static PyObject *__pyx_n_s_generation; static PyObject *__pyx_n_s_get; static PyObject *__pyx_n_s_getLogger; static PyObject *__pyx_n_s_get_ino_t_bits; static PyObject *__pyx_n_s_get_off_t_bits; static PyObject *__pyx_n_s_getattr; static PyObject *__pyx_n_s_getfilesystemencoding; static PyObject *__pyx_n_s_getxattr; static PyObject *__pyx_n_s_gid; static PyObject *__pyx_kp_u_handler_raised_exception_sending; static PyObject *__pyx_kp_s_home_nikratio_in_progress_pytho; static PyObject *__pyx_kp_s_home_nikratio_in_progress_pytho_2; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_s_ino; static PyObject *__pyx_n_s_inode; static PyObject *__pyx_n_u_inode; static PyObject *__pyx_n_s_inode_p; static PyObject *__pyx_n_u_inode_p; static PyObject *__pyx_n_s_inval_entry_req; static PyObject *__pyx_n_u_inval_entry_req; static PyObject *__pyx_n_s_inval_inode_req; static PyObject *__pyx_n_u_inval_inode_req; static PyObject *__pyx_n_s_invalidate_entry; static PyObject *__pyx_n_s_invalidate_inode; static PyObject *__pyx_n_s_join; static PyObject *__pyx_n_s_len; static PyObject *__pyx_n_s_link; static PyObject *__pyx_n_s_listdir; static PyObject *__pyx_n_s_listxattr; static PyObject *__pyx_n_u_llfuse; static PyObject *__pyx_n_s_llfuse_capi; static PyObject *__pyx_n_s_llfuse_pyapi; static PyObject *__pyx_n_s_lock; static PyObject *__pyx_n_s_lock_released; static PyObject *__pyx_n_s_log; static PyObject *__pyx_n_s_logging; static PyObject *__pyx_n_s_lookup; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_main_2; static PyObject *__pyx_n_s_maxsize; static PyObject *__pyx_n_s_mkdir; static PyObject *__pyx_n_s_mknod; static PyObject *__pyx_n_s_mountpoint; static PyObject *__pyx_kp_u_mountpoint__argument_must_be_of; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_u_name; static PyObject *__pyx_kp_u_name_argument_must_be_of_type_s; static PyObject *__pyx_n_s_name_b; static PyObject *__pyx_n_s_namedtuple; static PyObject *__pyx_n_s_names; static PyObject *__pyx_n_s_namespace; static PyObject *__pyx_kp_u_namespace_parameter_must_be_sys; static PyObject *__pyx_n_s_notify_loop; static PyObject *__pyx_n_s_notify_queue; static PyObject *__pyx_kp_b_o; static PyObject *__pyx_n_s_open; static PyObject *__pyx_n_s_opendir; static PyObject *__pyx_n_s_ops; static PyObject *__pyx_n_s_os; static PyObject *__pyx_n_s_os_path; static PyObject *__pyx_n_s_path; static PyObject *__pyx_kp_u_path_argument_must_be_of_type_s; static PyObject *__pyx_n_s_path_b; static PyObject *__pyx_n_s_pid; static PyObject *__pyx_n_s_put; static PyObject *__pyx_n_s_queue; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_read; static PyObject *__pyx_n_s_readdir; static PyObject *__pyx_n_s_readlink; static PyObject *__pyx_n_s_release; static PyObject *__pyx_n_s_releasedir; static PyObject *__pyx_n_s_removexattr; static PyObject *__pyx_n_s_rename; static PyObject *__pyx_n_s_req; static PyObject *__pyx_n_s_res; static PyObject *__pyx_n_s_ret; static PyObject *__pyx_n_s_rmdir; static PyObject *__pyx_n_s_setattr; static PyObject *__pyx_n_s_setxattr; static PyObject *__pyx_n_s_single; static PyObject *__pyx_n_s_size_guess; static PyObject *__pyx_n_s_st_atime; static PyObject *__pyx_n_s_st_atime_ns; static PyObject *__pyx_n_s_st_blksize; static PyObject *__pyx_n_s_st_blocks; static PyObject *__pyx_n_s_st_ctime; static PyObject *__pyx_n_s_st_ctime_ns; static PyObject *__pyx_n_s_st_gid; static PyObject *__pyx_n_s_st_ino; static PyObject *__pyx_n_s_st_mode; static PyObject *__pyx_n_s_st_mtime; static PyObject *__pyx_n_s_st_mtime_ns; static PyObject *__pyx_n_s_st_nlink; static PyObject *__pyx_n_s_st_rdev; static PyObject *__pyx_n_s_st_size; static PyObject *__pyx_n_s_st_uid; static PyObject *__pyx_n_s_stacktrace; static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_statfs; static PyObject *__pyx_n_s_str_t; static PyObject *__pyx_n_s_strerror; static PyObject *__pyx_n_u_surrogateescape; static PyObject *__pyx_n_s_symlink; static PyObject *__pyx_n_s_sys; static PyObject *__pyx_n_u_system; static PyObject *__pyx_n_s_t; static PyObject *__pyx_n_s_target; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_threading; static PyObject *__pyx_n_s_timeout; static PyObject *__pyx_n_s_tmp; static PyObject *__pyx_n_s_uid; static PyObject *__pyx_n_s_umask; static PyObject *__pyx_kp_u_unknown_flag_s_o; static PyObject *__pyx_n_s_unlink; static PyObject *__pyx_n_s_unmount; static PyObject *__pyx_kp_u_us_ascii; static PyObject *__pyx_n_u_user; static PyObject *__pyx_n_s_value; static PyObject *__pyx_n_s_version; static PyObject *__pyx_n_s_with_traceback; static PyObject *__pyx_n_s_write; static PyObject *__pyx_float_1e9; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_5; static PyObject *__pyx_int_1000; static PyObject *__pyx_int_1000000000; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__19; static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__21; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__27; static PyObject *__pyx_tuple__29; static PyObject *__pyx_tuple__30; static PyObject *__pyx_tuple__31; static PyObject *__pyx_tuple__32; static PyObject *__pyx_tuple__33; static PyObject *__pyx_tuple__34; static PyObject *__pyx_tuple__35; static PyObject *__pyx_tuple__36; static PyObject *__pyx_tuple__37; static PyObject *__pyx_tuple__38; static PyObject *__pyx_tuple__39; static PyObject *__pyx_tuple__40; static PyObject *__pyx_tuple__41; static PyObject *__pyx_tuple__42; static PyObject *__pyx_tuple__43; static PyObject *__pyx_tuple__44; static PyObject *__pyx_tuple__45; static PyObject *__pyx_tuple__46; static PyObject *__pyx_tuple__47; static PyObject *__pyx_tuple__48; static PyObject *__pyx_tuple__51; static PyObject *__pyx_tuple__52; static PyObject *__pyx_tuple__53; static PyObject *__pyx_tuple__54; static PyObject *__pyx_tuple__55; static PyObject *__pyx_tuple__56; static PyObject *__pyx_tuple__57; static PyObject *__pyx_tuple__58; static PyObject *__pyx_tuple__59; static PyObject *__pyx_tuple__60; static PyObject *__pyx_tuple__61; static PyObject *__pyx_tuple__62; static PyObject *__pyx_tuple__63; static PyObject *__pyx_tuple__64; static PyObject *__pyx_tuple__65; static PyObject *__pyx_tuple__66; static PyObject *__pyx_tuple__67; static PyObject *__pyx_tuple__68; static PyObject *__pyx_tuple__69; static PyObject *__pyx_tuple__70; static PyObject *__pyx_tuple__71; static PyObject *__pyx_tuple__72; static PyObject *__pyx_tuple__73; static PyObject *__pyx_tuple__74; static PyObject *__pyx_tuple__75; static PyObject *__pyx_tuple__76; static PyObject *__pyx_tuple__77; static PyObject *__pyx_tuple__79; static PyObject *__pyx_tuple__81; static PyObject *__pyx_tuple__83; static PyObject *__pyx_tuple__85; static PyObject *__pyx_tuple__87; static PyObject *__pyx_tuple__89; static PyObject *__pyx_tuple__91; static PyObject *__pyx_tuple__93; static PyObject *__pyx_codeobj__78; static PyObject *__pyx_codeobj__80; static PyObject *__pyx_codeobj__82; static PyObject *__pyx_codeobj__84; static PyObject *__pyx_codeobj__86; static PyObject *__pyx_codeobj__88; static PyObject *__pyx_codeobj__90; static PyObject *__pyx_codeobj__92; static PyObject *__pyx_codeobj__94; static PyObject *__pyx_codeobj__95; static PyObject *__pyx_codeobj__96; /* "src/llfuse/handlers.pxi":14 * ''' * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: # <<<<<<<<<<<<<< * try: * with lock: */ static void __pyx_f_6llfuse_4capi_fuse_init(CYTHON_UNUSED void *__pyx_v_userdata, CYTHON_UNUSED struct fuse_conn_info *__pyx_v_conn) { PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_init", 0); /* "src/llfuse/handlers.pxi":15 * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: # <<<<<<<<<<<<<< * with lock: * operations.init() */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":17 * try: * with lock: * operations.init() # <<<<<<<<<<<<<< * except BaseException as e: * handle_exc('init', e, NULL) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_init); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_13 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_14 = ((!(__pyx_t_13 != 0)) != 0); if (__pyx_t_14) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple_, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":18 * with lock: * operations.init() * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('init', e, NULL) * */ __pyx_t_15 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_15) { __Pyx_AddTraceback("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":19 * operations.init() * except BaseException as e: * handle_exc('init', e, NULL) # <<<<<<<<<<<<<< * * cdef void fuse_destroy (void *userdata) with gil: */ __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_init, __pyx_v_e, NULL); } /* "src/llfuse/handlers.pxi":18 * with lock: * operations.init() * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('init', e, NULL) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":14 * ''' * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: # <<<<<<<<<<<<<< * try: * with lock: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_WriteUnraisable("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":21 * handle_exc('init', e, NULL) * * cdef void fuse_destroy (void *userdata) with gil: # <<<<<<<<<<<<<< * # Note: called by fuse_session_destroy(), i.e. not as part of the * # main loop but only when llfuse.close() is called. */ static void __pyx_f_6llfuse_4capi_fuse_destroy(CYTHON_UNUSED void *__pyx_v_userdata) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_destroy", 0); /* "src/llfuse/handlers.pxi":26 * # (therefore we don't obtain the global lock) * global exc_info * try: # <<<<<<<<<<<<<< * operations.destroy() * except: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":27 * global exc_info * try: * operations.destroy() # <<<<<<<<<<<<<< * except: * if not exc_info: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_destroy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":28 * try: * operations.destroy() * except: # <<<<<<<<<<<<<< * if not exc_info: * exc_info = sys.exc_info() */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_destroy", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); /* "src/llfuse/handlers.pxi":29 * operations.destroy() * except: * if not exc_info: # <<<<<<<<<<<<<< * exc_info = sys.exc_info() * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __pyx_t_8 = ((!__pyx_t_7) != 0); if (__pyx_t_8) { /* "src/llfuse/handlers.pxi":30 * except: * if not exc_info: * exc_info = sys.exc_info() # <<<<<<<<<<<<<< * else: * log.exception('Exception after kill:') */ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_11))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (__pyx_t_10) { __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_10); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else { __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} } __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L13; } /*else*/ { /* "src/llfuse/handlers.pxi":32 * exc_info = sys.exc_info() * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, */ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_exception); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_L13:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_exception_handled; } __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":21 * handle_exc('init', e, NULL) * * cdef void fuse_destroy (void *userdata) with gil: # <<<<<<<<<<<<<< * # Note: called by fuse_session_destroy(), i.e. not as part of the * # main loop but only when llfuse.close() is called. */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_WriteUnraisable("llfuse.capi.fuse_destroy", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":34 * log.exception('Exception after kill:') * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef fuse_entry_param entry */ static void __pyx_f_6llfuse_4capi_fuse_lookup(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { struct fuse_entry_param __pyx_v_entry; int __pyx_v_ret; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_lookup", 0); /* "src/llfuse/handlers.pxi":39 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":41 * try: * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_lookup); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__3, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":42 * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_14 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":43 * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":44 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":45 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('lookup', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":44 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":46 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('lookup', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":47 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('lookup', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_lookup, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":46 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('lookup', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":49 * ret = handle_exc('lookup', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":50 * * if ret != 0: * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_lookup_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":34 * log.exception('Exception after kill:') * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef fuse_entry_param entry */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":53 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * ulong_t nlookup) with gil: * try: */ static void __pyx_f_6llfuse_4capi_fuse_forget(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, unsigned long __pyx_v_nlookup) { PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_forget", 0); /* "src/llfuse/handlers.pxi":55 * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, * ulong_t nlookup) with gil: * try: # <<<<<<<<<<<<<< * with lock: * operations.forget([(ino, nlookup)]) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":57 * try: * with lock: * operations.forget([(ino, nlookup)]) # <<<<<<<<<<<<<< * except BaseException as e: * handle_exc('forget', e, NULL) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_forget); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_unsigned_long(__pyx_v_nlookup); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_12) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__4, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":58 * with lock: * operations.forget([(ino, nlookup)]) * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('forget', e, NULL) * fuse_reply_none(req) */ __pyx_t_16 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":59 * operations.forget([(ino, nlookup)]) * except BaseException as e: * handle_exc('forget', e, NULL) # <<<<<<<<<<<<<< * fuse_reply_none(req) * */ __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_forget, __pyx_v_e, NULL); } /* "src/llfuse/handlers.pxi":58 * with lock: * operations.forget([(ino, nlookup)]) * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('forget', e, NULL) * fuse_reply_none(req) */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":60 * except BaseException as e: * handle_exc('forget', e, NULL) * fuse_reply_none(req) # <<<<<<<<<<<<<< * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, */ fuse_reply_none(__pyx_v_req); /* "src/llfuse/handlers.pxi":53 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * ulong_t nlookup) with gil: * try: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_WriteUnraisable("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":62 * fuse_reply_none(req) * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef c_stat stat */ static void __pyx_f_6llfuse_4capi_fuse_getattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, CYTHON_UNUSED struct fuse_file_info *__pyx_v_fi) { struct stat __pyx_v_stat; int __pyx_v_ret; int __pyx_v_timeout; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_getattr", 0); /* "src/llfuse/handlers.pxi":68 * cdef int timeout * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.getattr(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":70 * try: * with lock: * attr = operations.getattr(ino) # <<<<<<<<<<<<<< * * fill_c_stat(attr, &stat) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__5, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":72 * attr = operations.getattr(ino) * * fill_c_stat(attr, &stat) # <<<<<<<<<<<<<< * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_12 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":73 * * fill_c_stat(attr, &stat) * timeout = attr.attr_timeout # <<<<<<<<<<<<<< * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_timeout = __pyx_t_16; /* "src/llfuse/handlers.pxi":74 * fill_c_stat(attr, &stat) * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_attr(__pyx_v_req, (&__pyx_v_stat), __pyx_v_timeout); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":75 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":76 * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('getattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":75 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":77 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getattr', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":78 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('getattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_getattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":77 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":80 * ret = handle_exc('getattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":81 * * if ret != 0: * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_getattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":62 * fuse_reply_none(req) * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef c_stat stat */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":83 * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_setattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct stat *__pyx_v_stat, int __pyx_v_to_set, CYTHON_UNUSED struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; struct stat __pyx_v_stat_n; int __pyx_v_timeout; struct timespec __pyx_v_now; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_setattr", 0); /* "src/llfuse/handlers.pxi":90 * cdef timespec now * * try: # <<<<<<<<<<<<<< * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":91 * * try: * attr = EntryAttributes() # <<<<<<<<<<<<<< * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_EntryAttributes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":92 * try: * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): # <<<<<<<<<<<<<< * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: */ __pyx_t_7 = ((__pyx_v_to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW)) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":93 * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', */ __pyx_v_ret = clock_gettime(CLOCK_REALTIME, (&__pyx_v_now)); /* "src/llfuse/handlers.pxi":94 * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) */ __pyx_t_7 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":95 * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', # <<<<<<<<<<<<<< * strerror(errno.errno)) * */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/llfuse/handlers.pxi":96 * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) # <<<<<<<<<<<<<< * * # Type casting required on 64bit, where double */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_10) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = NULL; PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_11 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L12; } __pyx_L12:; goto __pyx_L11; } __pyx_L11:; /* "src/llfuse/handlers.pxi":100 * # Type casting required on 64bit, where double * # is smaller than long int. * if to_set & FUSE_SET_ATTR_ATIME: # <<<<<<<<<<<<<< * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_ATIME) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":101 * # is smaller than long int. * if to_set & FUSE_SET_ATTR_ATIME: * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 # <<<<<<<<<<<<<< * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: */ __pyx_t_4 = PyFloat_FromDouble((((double)__pyx_v_stat->st_atime) + (((double)GET_ATIME_NS(__pyx_v_stat)) * 1e-9))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":102 * if to_set & FUSE_SET_ATTR_ATIME: * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec */ __pyx_t_4 = __Pyx_PyInt_From_long(((__pyx_v_stat->st_atime * 1000000000) + GET_ATIME_NS(__pyx_v_stat))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 102; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 102; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L13; } /* "src/llfuse/handlers.pxi":103 * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: # <<<<<<<<<<<<<< * attr.st_atime = now.tv_sec * attr.st_atime_ns = now.tv_nsec */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_ATIME_NOW) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":104 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec # <<<<<<<<<<<<<< * attr.st_atime_ns = now.tv_nsec * else: */ __pyx_t_4 = __Pyx_PyInt_From_time_t(__pyx_v_now.tv_sec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":105 * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec * attr.st_atime_ns = now.tv_nsec # <<<<<<<<<<<<<< * else: * attr.st_atime = attr.st_atime_ns = None */ __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_now.tv_nsec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L13; } /*else*/ { /* "src/llfuse/handlers.pxi":107 * attr.st_atime_ns = now.tv_nsec * else: * attr.st_atime = attr.st_atime_ns = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_MTIME: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L13:; /* "src/llfuse/handlers.pxi":109 * attr.st_atime = attr.st_atime_ns = None * * if to_set & FUSE_SET_ATTR_MTIME: # <<<<<<<<<<<<<< * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MTIME) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":110 * * if to_set & FUSE_SET_ATTR_MTIME: * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 # <<<<<<<<<<<<<< * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: */ __pyx_t_4 = PyFloat_FromDouble((((double)__pyx_v_stat->st_mtime) + (((double)GET_MTIME_NS(__pyx_v_stat)) * 1e-9))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 110; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 110; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":111 * if to_set & FUSE_SET_ATTR_MTIME: * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec */ __pyx_t_4 = __Pyx_PyInt_From_long(((__pyx_v_stat->st_mtime * 1000000000) + GET_MTIME_NS(__pyx_v_stat))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 111; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 111; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L14; } /* "src/llfuse/handlers.pxi":112 * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: # <<<<<<<<<<<<<< * attr.st_mtime = now.tv_sec * attr.st_mtime_ns = now.tv_nsec */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MTIME_NOW) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":113 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec # <<<<<<<<<<<<<< * attr.st_mtime_ns = now.tv_nsec * else: */ __pyx_t_4 = __Pyx_PyInt_From_time_t(__pyx_v_now.tv_sec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":114 * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec * attr.st_mtime_ns = now.tv_nsec # <<<<<<<<<<<<<< * else: * attr.st_mtime = attr.st_mtime_ns = None */ __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_now.tv_nsec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 114; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 114; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L14; } /*else*/ { /* "src/llfuse/handlers.pxi":116 * attr.st_mtime_ns = now.tv_nsec * else: * attr.st_mtime = attr.st_mtime_ns = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_MODE: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 116; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 116; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L14:; /* "src/llfuse/handlers.pxi":118 * attr.st_mtime = attr.st_mtime_ns = None * * if to_set & FUSE_SET_ATTR_MODE: # <<<<<<<<<<<<<< * attr.st_mode = stat.st_mode * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MODE) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":119 * * if to_set & FUSE_SET_ATTR_MODE: * attr.st_mode = stat.st_mode # <<<<<<<<<<<<<< * else: * attr.st_mode = None */ __pyx_t_4 = __Pyx_PyInt_From_mode_t(__pyx_v_stat->st_mode); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L15; } /*else*/ { /* "src/llfuse/handlers.pxi":121 * attr.st_mode = stat.st_mode * else: * attr.st_mode = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_UID: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 121; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L15:; /* "src/llfuse/handlers.pxi":123 * attr.st_mode = None * * if to_set & FUSE_SET_ATTR_UID: # <<<<<<<<<<<<<< * attr.st_uid = stat.st_uid * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_UID) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":124 * * if to_set & FUSE_SET_ATTR_UID: * attr.st_uid = stat.st_uid # <<<<<<<<<<<<<< * else: * attr.st_uid = None */ __pyx_t_4 = __Pyx_PyInt_From_uid_t(__pyx_v_stat->st_uid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 124; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 124; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L16; } /*else*/ { /* "src/llfuse/handlers.pxi":126 * attr.st_uid = stat.st_uid * else: * attr.st_uid = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_GID: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 126; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L16:; /* "src/llfuse/handlers.pxi":128 * attr.st_uid = None * * if to_set & FUSE_SET_ATTR_GID: # <<<<<<<<<<<<<< * attr.st_gid = stat.st_gid * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_GID) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":129 * * if to_set & FUSE_SET_ATTR_GID: * attr.st_gid = stat.st_gid # <<<<<<<<<<<<<< * else: * attr.st_gid = None */ __pyx_t_4 = __Pyx_PyInt_From_gid_t(__pyx_v_stat->st_gid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 129; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 129; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L17; } /*else*/ { /* "src/llfuse/handlers.pxi":131 * attr.st_gid = stat.st_gid * else: * attr.st_gid = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_SIZE: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 131; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L17:; /* "src/llfuse/handlers.pxi":133 * attr.st_gid = None * * if to_set & FUSE_SET_ATTR_SIZE: # <<<<<<<<<<<<<< * attr.st_size = stat.st_size * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_SIZE) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":134 * * if to_set & FUSE_SET_ATTR_SIZE: * attr.st_size = stat.st_size # <<<<<<<<<<<<<< * else: * attr.st_size = None */ __pyx_t_4 = __Pyx_PyInt_From_off_t(__pyx_v_stat->st_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 134; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_size, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 134; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L18; } /*else*/ { /* "src/llfuse/handlers.pxi":136 * attr.st_size = stat.st_size * else: * attr.st_size = None # <<<<<<<<<<<<<< * * with lock: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_size, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 136; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L18:; /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_13 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_11 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_11))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (__pyx_t_5) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); /*try:*/ { /* "src/llfuse/handlers.pxi":139 * * with lock: * attr = operations.setattr(ino, attr) # <<<<<<<<<<<<<< * * fill_c_stat(attr, &stat_n) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_setattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_11 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_12, __pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); __Pyx_INCREF(__pyx_v_attr); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_12, __pyx_v_attr); __Pyx_GIVEREF(__pyx_v_attr); __pyx_t_11 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_attr, __pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L32_try_end; __pyx_L25_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); __pyx_t_11 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_11, NULL); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_7 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __pyx_t_18 = ((!(__pyx_t_7 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_8); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_8 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L26_exception_handled; } __pyx_L27_except_error:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); goto __pyx_L3_error; __pyx_L26_exception_handled:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_L32_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_13) { __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_tuple__6, NULL); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; } goto __pyx_L24; } __pyx_L24:; } goto __pyx_L36; __pyx_L19_error:; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L3_error; __pyx_L36:; } /* "src/llfuse/handlers.pxi":141 * attr = operations.setattr(ino, attr) * * fill_c_stat(attr, &stat_n) # <<<<<<<<<<<<<< * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) */ __pyx_t_8 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat_n)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/llfuse/handlers.pxi":142 * * fill_c_stat(attr, &stat_n) * timeout = attr.attr_timeout # <<<<<<<<<<<<<< * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_timeout = __pyx_t_19; /* "src/llfuse/handlers.pxi":143 * fill_c_stat(attr, &stat_n) * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_attr(__pyx_v_req, (&__pyx_v_stat_n), __pyx_v_timeout); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/llfuse/handlers.pxi":144 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":145 * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('setattr', e, req) */ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 145; __pyx_clineno = __LINE__; goto __pyx_L42_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 145; __pyx_clineno = __LINE__; goto __pyx_L42_error;} __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":144 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L43; } /*exception exit:*/{ __pyx_L42_error:; __pyx_t_13 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_17 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_17, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_16, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_16, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_17, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_16, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_17 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L43:; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":146 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setattr', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":147 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('setattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_setattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":146 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L54; } __pyx_L54:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":149 * ret = handle_exc('setattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":150 * * if ret != 0: * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_11))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (!__pyx_t_9) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_11)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_11); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_10 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_11) { PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); __pyx_t_11 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_12, __pyx_kp_u_fuse_setattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L55; } __pyx_L55:; /* "src/llfuse/handlers.pxi":83 * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_WriteUnraisable("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":152 * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ static void __pyx_f_6llfuse_4capi_fuse_readlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino) { int __pyx_v_ret; char *__pyx_v_name; PyObject *__pyx_v_target = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; char *__pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; Py_ssize_t __pyx_t_23; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_readlink", 0); /* "src/llfuse/handlers.pxi":155 * cdef int ret * cdef char* name * try: # <<<<<<<<<<<<<< * with lock: * target = operations.readlink(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":157 * try: * with lock: * target = operations.readlink(ino) # <<<<<<<<<<<<<< * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_readlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_target = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":158 * with lock: * target = operations.readlink(ino) * name = PyBytes_AsString(target) # <<<<<<<<<<<<<< * ret = fuse_reply_readlink(req, name) * except FUSEError as e: */ if (unlikely(!__pyx_v_target)) { __Pyx_RaiseUnboundLocalError("target"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 158; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = PyBytes_AsString(__pyx_v_target); if (unlikely(__pyx_t_16 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 158; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_name = __pyx_t_16; /* "src/llfuse/handlers.pxi":159 * target = operations.readlink(ino) * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_readlink(__pyx_v_req, __pyx_v_name); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":160 * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 160; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 160; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":161 * ret = fuse_reply_readlink(req, name) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('readlink', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":160 * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":162 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readlink', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 162; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":163 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('readlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_readlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":162 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":165 * ret = handle_exc('readlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":166 * * if ret != 0: * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_23 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_23 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_23); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_23, __pyx_kp_u_fuse_readlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_23, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":152 * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_target); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":168 * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_mknod(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode, dev_t __pyx_v_rdev) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_mknod", 0); /* "src/llfuse/handlers.pxi":173 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":174 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 174; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":176 * ctx = get_request_context(req) * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, # <<<<<<<<<<<<<< * rdev, ctx) * fill_entry_param(attr, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_mknod); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); /* "src/llfuse/handlers.pxi":177 * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_13 = __Pyx_PyInt_From_dev_t(__pyx_v_rdev); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 177; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } __pyx_t_16 = PyTuple_New(5+__pyx_t_15); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_16); if (__pyx_t_14) { PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = NULL; } PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_16, 4+__pyx_t_15, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_16, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_16); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_18 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_19 = ((!(__pyx_t_18 != 0)) != 0); if (__pyx_t_19) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_16); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":178 * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":179 * rdev, ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":180 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_16 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 180; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_16, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 180; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":181 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('mknod', e, req) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_13); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); } /* "src/llfuse/handlers.pxi":180 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_17, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_20 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_17, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":182 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mknod', e, req) * */ __pyx_t_21 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 182; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":183 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('mknod', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_mknod, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":182 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mknod', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":185 * ret = handle_exc('mknod', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/llfuse/handlers.pxi":186 * * if ret != 0: * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_13))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } if (!__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_15 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_15, __pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_15, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":168 * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_16); __Pyx_WriteUnraisable("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":188 * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_mkdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_mkdir", 0); /* "src/llfuse/handlers.pxi":193 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * # Force the entry type to directory. We need to explicitly cast, * # because on BSD the S_* are not of type mode_t. */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":196 * # Force the entry type to directory. We need to explicitly cast, * # because on BSD the S_* are not of type mode_t. * mode = ((mode & ~S_IFMT) | S_IFDIR) # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ __pyx_v_mode = ((mode_t)((__pyx_v_mode & (~S_IFMT)) | S_IFDIR)); /* "src/llfuse/handlers.pxi":197 * # because on BSD the S_* are not of type mode_t. * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 197; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":199 * ctx = get_request_context(req) * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_mkdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__9, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":200 * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":201 * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":202 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 202; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 202; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":203 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('mkdir', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":202 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":204 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mkdir', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 204; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":205 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('mkdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_mkdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":204 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mkdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":207 * ret = handle_exc('mkdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":208 * * if ret != 0: * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":188 * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":210 * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_unlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_unlink", 0); /* "src/llfuse/handlers.pxi":213 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.unlink(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":215 * try: * with lock: * operations.unlink(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_unlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__10, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":216 * with lock: * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":217 * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":218 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('unlink', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":217 * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":219 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('unlink', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":220 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('unlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_unlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":219 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('unlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":222 * ret = handle_exc('unlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":223 * * if ret != 0: * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_unlink_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":210 * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":225 * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_rmdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_rmdir", 0); /* "src/llfuse/handlers.pxi":228 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":230 * try: * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_rmdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__11, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":231 * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":232 * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 232; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 232; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":233 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('rmdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":232 * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":234 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rmdir', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":235 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('rmdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_rmdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":234 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rmdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":237 * ret = handle_exc('rmdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":238 * * if ret != 0: * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":225 * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":240 * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_symlink(fuse_req_t __pyx_v_req, const char *__pyx_v_link, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_symlink", 0); /* "src/llfuse/handlers.pxi":245 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":246 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":248 * ctx = get_request_context(req) * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), # <<<<<<<<<<<<<< * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_symlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); /* "src/llfuse/handlers.pxi":249 * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_12 = PyBytes_FromString(__pyx_v_link); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 249; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":250 * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":251 * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":252 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":253 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('symlink', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":252 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":254 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('symlink', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 254; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":255 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('symlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_symlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":254 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('symlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":257 * ret = handle_exc('symlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":258 * * if ret != 0: * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_symlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":240 * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":260 * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_rename(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_rename", 0); /* "src/llfuse/handlers.pxi":264 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.rename(parent, PyBytes_FromString(name), */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":266 * try: * with lock: * operations.rename(parent, PyBytes_FromString(name), # <<<<<<<<<<<<<< * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_rename); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); /* "src/llfuse/handlers.pxi":267 * with lock: * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_12 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_newparent); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } __pyx_t_16 = PyTuple_New(4+__pyx_t_15); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_16); if (__pyx_t_14) { PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = NULL; } PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_16, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_16); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_18 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_19 = ((!(__pyx_t_18 != 0)) != 0); if (__pyx_t_19) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_16); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":268 * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":269 * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_16 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_16, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":270 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('rename', e, req) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_13); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); } /* "src/llfuse/handlers.pxi":269 * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_17, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_20 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_17, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":271 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rename', e, req) * */ __pyx_t_21 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":272 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('rename', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_rename, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":271 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rename', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":274 * ret = handle_exc('rename', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/llfuse/handlers.pxi":275 * * if ret != 0: * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_13))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } if (!__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_15 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_15, __pyx_kp_u_fuse_rename_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_15, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":260 * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_16); __Pyx_WriteUnraisable("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":277 * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_link(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_link", 0); /* "src/llfuse/handlers.pxi":282 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":284 * try: * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_link); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_newparent); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__14, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":285 * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":286 * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":287 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":288 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('link', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":287 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":289 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('link', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":290 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('link', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_link, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":289 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('link', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":292 * ret = handle_exc('link', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":293 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":277 * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":296 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_open(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; uint64_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_open", 0); /* "src/llfuse/handlers.pxi":299 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * fi.fh = operations.open(ino, fi.flags) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":301 * try: * with lock: * fi.fh = operations.open(ino, fi.flags) # <<<<<<<<<<<<<< * * # Cached file data does not need to be invalidated. */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_open); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_fi->flags); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyInt_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_15 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_fi->fh = __pyx_t_15; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__15, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":305 * # Cached file data does not need to be invalidated. * # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ * fi.keep_cache = 1 # <<<<<<<<<<<<<< * * ret = fuse_reply_open(req, fi) */ __pyx_v_fi->keep_cache = 1; /* "src/llfuse/handlers.pxi":307 * fi.keep_cache = 1 * * ret = fuse_reply_open(req, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_open(__pyx_v_req, __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":308 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":309 * ret = fuse_reply_open(req, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('open', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":308 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":310 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('open', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":311 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('open', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_open, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":310 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('open', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":313 * ret = handle_exc('open', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":314 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_23, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_23, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_23 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_23); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_23, 0+__pyx_t_13, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_23, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_23, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":296 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_23); __Pyx_WriteUnraisable("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":316 * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_read(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_read", 0); /* "src/llfuse/handlers.pxi":322 * cdef char* cbuf * * try: # <<<<<<<<<<<<<< * with lock: * buf = operations.read(fi.fh, off, size) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":324 * try: * with lock: * buf = operations.read(fi.fh, off, size) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_read); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__16, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":325 * with lock: * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_19 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_19 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":326 * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":327 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":328 * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('read', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":327 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":329 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('read', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":330 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('read', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_read, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":329 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('read', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":332 * ret = handle_exc('read', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":333 * * if ret != 0: * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_read_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":316 * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":335 * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_write(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, const char *__pyx_v_buf, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; size_t __pyx_v_len_; PyObject *__pyx_v_pbuf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; size_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_t_24; char const *__pyx_t_25; PyObject *__pyx_t_26 = NULL; char const *__pyx_t_27; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_write", 0); /* "src/llfuse/handlers.pxi":341 * * # GCC thinks this may end up uninitialized * len_ = 0 # <<<<<<<<<<<<<< * * try: */ __pyx_v_len_ = 0; /* "src/llfuse/handlers.pxi":343 * len_ = 0 * * try: # <<<<<<<<<<<<<< * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":344 * * try: * pbuf = PyBytes_FromStringAndSize(buf, size) # <<<<<<<<<<<<<< * with lock: * len_ = operations.write(fi.fh, off, pbuf) */ __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_pbuf = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":346 * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: * len_ = operations.write(fi.fh, off, pbuf) # <<<<<<<<<<<<<< * ret = fuse_reply_write(req, len_) * if ret != 0: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_write); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_pbuf); PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_v_pbuf); __Pyx_GIVEREF(__pyx_v_pbuf); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_len_ = __pyx_t_15; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__17, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":347 * with lock: * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) */ __pyx_v_ret = fuse_reply_write(__pyx_v_req, __pyx_v_len_); /* "src/llfuse/handlers.pxi":348 * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":349 * ret = fuse_reply_write(req, len_) * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_19 = PyTuple_New(1+1); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_19); PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_19, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_19, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_19 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_19); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_write_fail); PyTuple_SET_ITEM(__pyx_t_19, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_write_fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_write_fail); PyTuple_SET_ITEM(__pyx_t_19, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_19, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L29; } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":350 * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * if ret != 0: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_4, &__pyx_t_19) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_19); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":351 * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); /* "src/llfuse/handlers.pxi":352 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":353 * ret = fuse_reply_err(req, e.errno) * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('write', e, req) */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_21 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_21); __pyx_t_22 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_22)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_22); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_22) { __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_21); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_GOTREF(__pyx_t_8); } else { __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_22); __Pyx_GIVEREF(__pyx_t_22); __pyx_t_22 = NULL; PyTuple_SET_ITEM(__pyx_t_23, 0+1, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = 0; __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_23, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_23 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_23)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_23); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_13 = 1; } } __pyx_t_21 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_23) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_23); __Pyx_GIVEREF(__pyx_t_23); __pyx_t_23 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_err_d_fail); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_err_d_fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_err_d_fail); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_21, 2+__pyx_t_13, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L37; } __pyx_L37:; } /* "src/llfuse/handlers.pxi":350 * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * if ret != 0: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_26); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_26); __pyx_t_20 = __pyx_lineno; __pyx_t_24 = __pyx_clineno; __pyx_t_25 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_26); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_26); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_26 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_24; __pyx_filename = __pyx_t_25; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":354 * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('write', e, req) * */ __pyx_t_24 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_24) { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_19, &__pyx_t_4, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_19); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":355 * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: * ret = handle_exc('write', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_write, __pyx_v_e, __pyx_v_req); /* "src/llfuse/handlers.pxi":357 * ret = handle_exc('write', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":358 * * if ret != 0: * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_error); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_21); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_23 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_23)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_23); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_23) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_23); __Pyx_GIVEREF(__pyx_t_23); __pyx_t_23 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_22, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_21))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_21); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_21); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_21, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_err_failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_err_failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_err_failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_21, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L49; } __pyx_L49:; } /* "src/llfuse/handlers.pxi":354 * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('write', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } /*exception exit:*/{ __pyx_L47_error:; __pyx_t_26 = 0; __pyx_t_16 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_5); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_26, &__pyx_t_16, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_26, &__pyx_t_16, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_26); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_5); __pyx_t_24 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_27 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_5); } __Pyx_XGIVEREF(__pyx_t_26); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ErrRestore(__pyx_t_26, __pyx_t_16, __pyx_t_9); __pyx_t_26 = 0; __pyx_t_16 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_5 = 0; __pyx_lineno = __pyx_t_24; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_27; goto __pyx_L5_except_error; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":335 * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_XDECREF(__pyx_t_23); __Pyx_WriteUnraisable("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_pbuf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":360 * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_flush(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_flush", 0); /* "src/llfuse/handlers.pxi":363 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.flush(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":365 * try: * with lock: * operations.flush(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_flush); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__18, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":366 * with lock: * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":367 * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":368 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('flush', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":367 * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":369 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('flush', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":370 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('flush', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_flush, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":369 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('flush', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":372 * ret = handle_exc('flush', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":373 * * if ret != 0: * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_flush_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":360 * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":375 * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_release(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_release", 0); /* "src/llfuse/handlers.pxi":378 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.release(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":380 * try: * with lock: * operations.release(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_release); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__19, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":381 * with lock: * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":382 * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 382; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 382; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":383 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('release', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":382 * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":384 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('release', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 384; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":385 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('release', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_release, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":384 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('release', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":387 * ret = handle_exc('release', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":388 * * if ret != 0: * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_release_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_release_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_release_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":375 * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":390 * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_fsync(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_fsync", 0); /* "src/llfuse/handlers.pxi":394 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.fsync(fi.fh, datasync != 0) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":396 * try: * with lock: * operations.fsync(fi.fh, datasync != 0) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_fsync); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyBool_FromLong((__pyx_v_datasync != 0)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__20, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":397 * with lock: * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":398 * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":399 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('fsync', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 399; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 399; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":398 * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":400 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsync', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":401 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('fsync', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_fsync, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":400 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsync', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":403 * ret = handle_exc('fsync', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":404 * * if ret != 0: * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":390 * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":406 * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_opendir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; uint64_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; Py_ssize_t __pyx_t_23; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_opendir", 0); /* "src/llfuse/handlers.pxi":409 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * fi.fh = operations.opendir(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":411 * try: * with lock: * fi.fh = operations.opendir(ino) # <<<<<<<<<<<<<< * * ret = fuse_reply_open(req, fi) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_opendir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyInt_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_13 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_fi->fh = __pyx_t_13; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__21, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":413 * fi.fh = operations.opendir(ino) * * ret = fuse_reply_open(req, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_open(__pyx_v_req, __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":414 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":415 * ret = fuse_reply_open(req, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('opendir', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":414 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":416 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('opendir', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":417 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('opendir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_opendir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":416 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('opendir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":419 * ret = handle_exc('opendir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":420 * * if ret != 0: * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_23 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_23 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_23); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_23, __pyx_kp_u_fuse_opendir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_23, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":406 * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":422 * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_readdir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; char *__pyx_v_cname; char *__pyx_v_buf; size_t __pyx_v_len_; size_t __pyx_v_acc_size; struct stat __pyx_v_stat; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_next_ = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *(*__pyx_t_15)(PyObject *); PyObject *(*__pyx_t_16)(PyObject *); int __pyx_t_17; char *__pyx_t_18; off_t __pyx_t_19; PyObject *__pyx_t_20 = NULL; int __pyx_t_21; int __pyx_t_22; int __pyx_t_23; char const *__pyx_t_24; PyObject *__pyx_t_25 = NULL; char const *__pyx_t_26; PyObject *__pyx_t_27 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_readdir", 0); /* "src/llfuse/handlers.pxi":431 * * # GCC thinks this may end up uninitialized * ret = 0 # <<<<<<<<<<<<<< * * try: */ __pyx_v_ret = 0; /* "src/llfuse/handlers.pxi":433 * ret = 0 * * try: # <<<<<<<<<<<<<< * acc_size = 0 * buf = NULL */ /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":434 * * try: * acc_size = 0 # <<<<<<<<<<<<<< * buf = NULL * with lock: */ __pyx_v_acc_size = 0; /* "src/llfuse/handlers.pxi":435 * try: * acc_size = 0 * buf = NULL # <<<<<<<<<<<<<< * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): */ __pyx_v_buf = NULL; /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":437 * buf = NULL * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): # <<<<<<<<<<<<<< * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_readdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { __pyx_t_6 = __pyx_t_4; __Pyx_INCREF(__pyx_t_6); __pyx_t_13 = 0; __pyx_t_15 = NULL; } else { __pyx_t_13 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { if (likely(!__pyx_t_15)) { if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_6, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #endif } else { if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_6, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #endif } } else { __pyx_t_4 = __pyx_t_15(__pyx_t_6); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } break; } __Pyx_GOTREF(__pyx_t_4); } if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { PyObject* sequence = __pyx_t_4; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_14 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 2); } else { __pyx_t_14 = PyList_GET_ITEM(sequence, 0); __pyx_t_8 = PyList_GET_ITEM(sequence, 1); __pyx_t_7 = PyList_GET_ITEM(sequence, 2); } __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); #else __pyx_t_14 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { Py_ssize_t index = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_16 = Py_TYPE(__pyx_t_12)->tp_iternext; index = 0; __pyx_t_14 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_14)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_14); index = 1; __pyx_t_8 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_8)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_8); index = 2; __pyx_t_7 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_7)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_12), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_t_16 = NULL; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L31_unpacking_done; __pyx_L30_unpacking_failed:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_16 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_L31_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF_SET(__pyx_v_attr, __pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF_SET(__pyx_v_next_, __pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":438 * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: # <<<<<<<<<<<<<< * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) */ __pyx_t_17 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":439 * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) # <<<<<<<<<<<<<< * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) */ __pyx_v_buf = ((char *)malloc((__pyx_v_size * (sizeof(char))))); goto __pyx_L32; } __pyx_L32:; /* "src/llfuse/handlers.pxi":440 * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) # <<<<<<<<<<<<<< * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, */ __pyx_t_18 = PyBytes_AsString(__pyx_v_name); if (unlikely(__pyx_t_18 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 440; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_v_cname = __pyx_t_18; /* "src/llfuse/handlers.pxi":441 * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) # <<<<<<<<<<<<<< * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":443 * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) # <<<<<<<<<<<<<< * if len_ > (size - acc_size): * break */ __pyx_t_19 = __Pyx_PyInt_As_off_t(__pyx_v_next_); if (unlikely((__pyx_t_19 == (off_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L20_error;} /* "src/llfuse/handlers.pxi":442 * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, # <<<<<<<<<<<<<< * cname, &stat, next_) * if len_ > (size - acc_size): */ __pyx_v_len_ = fuse_add_direntry(__pyx_v_req, (__pyx_v_buf + __pyx_v_acc_size), (__pyx_v_size - __pyx_v_acc_size), __pyx_v_cname, (&__pyx_v_stat), __pyx_t_19); /* "src/llfuse/handlers.pxi":444 * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) * if len_ > (size - acc_size): # <<<<<<<<<<<<<< * break * acc_size += len_ */ __pyx_t_17 = ((__pyx_v_len_ > (__pyx_v_size - __pyx_v_acc_size)) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":445 * cname, &stat, next_) * if len_ > (size - acc_size): * break # <<<<<<<<<<<<<< * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) */ goto __pyx_L29_break; } /* "src/llfuse/handlers.pxi":446 * if len_ > (size - acc_size): * break * acc_size += len_ # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: */ __pyx_v_acc_size = (__pyx_v_acc_size + __pyx_v_len_); /* "src/llfuse/handlers.pxi":437 * buf = NULL * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): # <<<<<<<<<<<<<< * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) */ } __pyx_L29_break:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L27_try_end; __pyx_L20_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_4, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_20); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_20); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __pyx_t_21 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_21) { __Pyx_GIVEREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_6, __pyx_t_4, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_4 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L21_exception_handled; } __pyx_L22_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L6_error; __pyx_L21_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L27_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__22, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L19; } __pyx_L19:; } goto __pyx_L37; __pyx_L14_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L6_error; __pyx_L37:; } /* "src/llfuse/handlers.pxi":447 * break * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_buf, __pyx_v_acc_size); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L13_try_end; __pyx_L6_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":448 * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_22 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_22) { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":449 * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('readdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_22 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_22 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_22); } /* "src/llfuse/handlers.pxi":448 * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L44; } /*exception exit:*/{ __pyx_L43_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_25 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_20, &__pyx_t_25); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_25); __pyx_t_22 = __pyx_lineno; __pyx_t_23 = __pyx_clineno; __pyx_t_24 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_20, __pyx_t_25); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_25 = 0; __pyx_lineno = __pyx_t_22; __pyx_clineno = __pyx_t_23; __pyx_filename = __pyx_t_24; goto __pyx_L8_except_error; } __pyx_L44:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L7_exception_handled; } /* "src/llfuse/handlers.pxi":450 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readdir', e, req) * finally: */ __pyx_t_23 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_23) { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_4, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":451 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('readdir', e, req) # <<<<<<<<<<<<<< * finally: * if buf != NULL: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_readdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":450 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readdir', e, req) * finally: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L55; } __pyx_L55:; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L7_exception_handled; } goto __pyx_L8_except_error; __pyx_L8_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L4_error; __pyx_L7_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L13_try_end:; } } /* "src/llfuse/handlers.pxi":453 * ret = handle_exc('readdir', e, req) * finally: * if buf != NULL: # <<<<<<<<<<<<<< * stdlib.free(buf) * */ /*finally:*/ { /*normal exit:*/{ __pyx_t_21 = ((__pyx_v_buf != NULL) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":454 * finally: * if buf != NULL: * stdlib.free(buf) # <<<<<<<<<<<<<< * * if ret != 0: */ free(__pyx_v_buf); goto __pyx_L56; } __pyx_L56:; goto __pyx_L5; } /*exception exit:*/{ __pyx_L4_error:; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_25 = 0; __pyx_t_20 = 0; __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_25, &__pyx_t_20, &__pyx_t_9); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0)) __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_25); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_9); __pyx_t_23 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_26 = __pyx_filename; { /* "src/llfuse/handlers.pxi":453 * ret = handle_exc('readdir', e, req) * finally: * if buf != NULL: # <<<<<<<<<<<<<< * stdlib.free(buf) * */ __pyx_t_21 = ((__pyx_v_buf != NULL) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":454 * finally: * if buf != NULL: * stdlib.free(buf) # <<<<<<<<<<<<<< * * if ret != 0: */ free(__pyx_v_buf); goto __pyx_L59; } __pyx_L59:; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_25); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_20, __pyx_t_9); } __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_1); __Pyx_ErrRestore(__pyx_t_3, __pyx_t_2, __pyx_t_1); __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_25 = 0; __pyx_t_20 = 0; __pyx_t_9 = 0; __pyx_lineno = __pyx_t_23; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_26; goto __pyx_L1_error; } __pyx_L5:; } /* "src/llfuse/handlers.pxi":456 * stdlib.free(buf) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_21 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":457 * * if ret != 0: * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_14 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_14); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_27 = PyTuple_New(1+1); if (unlikely(!__pyx_t_27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_27); PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_27, 0+1, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_27, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_27 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_27); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_27, 0+__pyx_t_13, __pyx_kp_u_fuse_readdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_readdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_27, 1+__pyx_t_13, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_27, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L60; } __pyx_L60:; /* "src/llfuse/handlers.pxi":422 * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_27); __Pyx_WriteUnraisable("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_next_); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":459 * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_releasedir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_releasedir", 0); /* "src/llfuse/handlers.pxi":462 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.releasedir(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":464 * try: * with lock: * operations.releasedir(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_releasedir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__23, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":465 * with lock: * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":466 * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":467 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('releasedir', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":466 * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":468 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('releasedir', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 468; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":469 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('releasedir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_releasedir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":468 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('releasedir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":471 * ret = handle_exc('releasedir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":472 * * if ret != 0: * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_releasedir_fuse_reply__fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":459 * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":475 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_fsyncdir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_fsyncdir", 0); /* "src/llfuse/handlers.pxi":479 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.fsyncdir(fi.fh, datasync != 0) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":481 * try: * with lock: * operations.fsyncdir(fi.fh, datasync != 0) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_fsyncdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyBool_FromLong((__pyx_v_datasync != 0)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__24, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":482 * with lock: * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":483 * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":484 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('fsyncdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":483 * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":485 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsyncdir', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 485; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":486 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('fsyncdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_fsyncdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":485 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsyncdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":488 * ret = handle_exc('fsyncdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":489 * * if ret != 0: * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":475 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":492 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef statvfs cstats */ static void __pyx_f_6llfuse_4capi_fuse_statfs(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino) { int __pyx_v_ret; struct statvfs __pyx_v_cstats; PyObject *__pyx_v_stats = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; char const *__pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_statfs", 0); /* "src/llfuse/handlers.pxi":497 * * # We don't set all the components * string.memset(&cstats, 0, sizeof(cstats)) # <<<<<<<<<<<<<< * try: * with lock: */ memset((&__pyx_v_cstats), 0, (sizeof(__pyx_v_cstats))); /* "src/llfuse/handlers.pxi":498 * # We don't set all the components * string.memset(&cstats, 0, sizeof(cstats)) * try: # <<<<<<<<<<<<<< * with lock: * stats = operations.statfs() */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":500 * try: * with lock: * stats = operations.statfs() # <<<<<<<<<<<<<< * * fill_statvfs(stats, &cstats) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_statfs); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_stats = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_13 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_14 = ((!(__pyx_t_13 != 0)) != 0); if (__pyx_t_14) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__25, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":502 * stats = operations.statfs() * * fill_statvfs(stats, &cstats) # <<<<<<<<<<<<<< * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: */ if (unlikely(!__pyx_v_stats)) { __Pyx_RaiseUnboundLocalError("stats"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_7 = __pyx_f_6llfuse_4capi_fill_statvfs(__pyx_v_stats, (&__pyx_v_cstats)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":503 * * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_statfs(__pyx_v_req, (&__pyx_v_cstats)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":504 * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_15) { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":505 * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('statfs', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 505; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_15 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 505; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_15); } /* "src/llfuse/handlers.pxi":504 * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_12 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_12, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_15 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_12, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_12 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_15; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":506 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('statfs', e, req) * */ __pyx_t_16 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 506; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":507 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('statfs', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_statfs, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":506 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('statfs', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":509 * ret = handle_exc('statfs', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_14 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_14) { /* "src/llfuse/handlers.pxi":510 * * if ret != 0: * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * IF TARGET_PLATFORM == 'darwin': */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_19); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_19); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_19); __Pyx_GIVEREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_statfs_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":492 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef statvfs cstats */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_stats); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":513 * * IF TARGET_PLATFORM == 'darwin': * cdef void fuse_setxattr_darwin (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags, * uint32_t position) with gil: */ static void __pyx_f_6llfuse_4capi_fuse_setxattr_darwin(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, const char *__pyx_v_cvalue, size_t __pyx_v_size, int __pyx_v_flags, uint32_t __pyx_v_position) { int __pyx_v_ret; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_setxattr_darwin", 0); /* "src/llfuse/handlers.pxi":518 * cdef int ret * * if position != 0: # <<<<<<<<<<<<<< * log.error('fuse_setxattr(): non-zero position (%d) not supported', position) * ret = fuse_reply_err(req, errno.EIO) */ __pyx_t_1 = ((__pyx_v_position != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/handlers.pxi":519 * * if position != 0: * log.error('fuse_setxattr(): non-zero position (%d) not supported', position) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, errno.EIO) * if ret != 0: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_position); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setxattr_non_zero_position); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_kp_u_fuse_setxattr_non_zero_position); __Pyx_GIVEREF(__pyx_kp_u_fuse_setxattr_non_zero_position); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 519; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/handlers.pxi":520 * if position != 0: * log.error('fuse_setxattr(): non-zero position (%d) not supported', position) * ret = fuse_reply_err(req, errno.EIO) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_setxattr(): fuse_reply_err failed with %s', strerror(-ret)) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, EIO); /* "src/llfuse/handlers.pxi":521 * log.error('fuse_setxattr(): non-zero position (%d) not supported', position) * ret = fuse_reply_err(req, errno.EIO) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setxattr(): fuse_reply_err failed with %s', strerror(-ret)) * return */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/handlers.pxi":522 * ret = fuse_reply_err(req, errno.EIO) * if ret != 0: * log.error('fuse_setxattr(): fuse_reply_err failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * return * */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_6 = 1; } } __pyx_t_9 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_3) { PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setxattr_fuse_reply_err_fai); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_6, __pyx_kp_u_fuse_setxattr_fuse_reply_err_fai); __Pyx_GIVEREF(__pyx_kp_u_fuse_setxattr_fuse_reply_err_fai); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 522; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L4; } __pyx_L4:; /* "src/llfuse/handlers.pxi":523 * if ret != 0: * log.error('fuse_setxattr(): fuse_reply_err failed with %s', strerror(-ret)) * return # <<<<<<<<<<<<<< * * # Filter out flags that don't make any sense for a FUSE */ goto __pyx_L0; } /* "src/llfuse/handlers.pxi":529 * # passes through. * # (cf. https://groups.google.com/d/msg/fuse4x/bRnh7J_nsts/Z7raJ06DB4sJ) * flags &= ~(xattr.XATTR_NOFOLLOW | xattr.XATTR_NODEFAULT | # <<<<<<<<<<<<<< * xattr.XATTR_NOSECURITY) * fuse_setxattr(req, ino, cname, cvalue, size, flags) */ __pyx_v_flags = (__pyx_v_flags & (~((XATTR_NOFOLLOW | XATTR_NODEFAULT) | XATTR_NOSECURITY))); /* "src/llfuse/handlers.pxi":531 * flags &= ~(xattr.XATTR_NOFOLLOW | xattr.XATTR_NODEFAULT | * xattr.XATTR_NOSECURITY) * fuse_setxattr(req, ino, cname, cvalue, size, flags) # <<<<<<<<<<<<<< * * */ __pyx_f_6llfuse_4capi_fuse_setxattr(__pyx_v_req, __pyx_v_ino, __pyx_v_cname, __pyx_v_cvalue, __pyx_v_size, __pyx_v_flags); /* "src/llfuse/handlers.pxi":513 * * IF TARGET_PLATFORM == 'darwin': * cdef void fuse_setxattr_darwin (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags, * uint32_t position) with gil: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_WriteUnraisable("llfuse.capi.fuse_setxattr_darwin", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":534 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_setxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, const char *__pyx_v_cvalue, size_t __pyx_v_size, int __pyx_v_flags) { int __pyx_v_ret; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; Py_ssize_t __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; PyObject *__pyx_t_20 = NULL; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; PyObject *__pyx_t_24 = NULL; PyObject *__pyx_t_25 = NULL; PyObject *__pyx_t_26 = NULL; PyObject *__pyx_t_27 = NULL; PyObject *__pyx_t_28 = NULL; char const *__pyx_t_29; PyObject *__pyx_t_30 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_setxattr", 0); /* "src/llfuse/handlers.pxi":538 * cdef int ret * * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * value = PyBytes_FromStringAndSize(cvalue, size) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":539 * * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * value = PyBytes_FromStringAndSize(cvalue, size) * */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 539; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":540 * try: * name = PyBytes_FromString(cname) * value = PyBytes_FromStringAndSize(cvalue, size) # <<<<<<<<<<<<<< * * # Special case for deadlock debugging */ __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_v_cvalue, __pyx_v_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_value = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":543 * * # Special case for deadlock debugging * if ino == FUSE_ROOT_ID and string.strcmp(cname, 'fuse_stacktrace') == 0: # <<<<<<<<<<<<<< * operations.stacktrace() * else: */ __pyx_t_6 = ((__pyx_v_ino == FUSE_ROOT_ID) != 0); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L12_bool_binop_done; } __pyx_t_6 = ((strcmp(__pyx_v_cname, __pyx_k_fuse_stacktrace) == 0) != 0); __pyx_t_5 = __pyx_t_6; __pyx_L12_bool_binop_done:; if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":544 * # Special case for deadlock debugging * if ino == FUSE_ROOT_ID and string.strcmp(cname, 'fuse_stacktrace') == 0: * operations.stacktrace() # <<<<<<<<<<<<<< * else: * IF TARGET_PLATFORM == 'freebsd': */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_stacktrace); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L11; } /*else*/ { /* "src/llfuse/handlers.pxi":552 * ELSE: * # Make sure we know all the flags * if flags & ~(xattr.XATTR_CREATE | xattr.XATTR_REPLACE): # <<<<<<<<<<<<<< * raise ValueError('unknown flag(s): %o' % flags) * */ __pyx_t_5 = ((__pyx_v_flags & (~(XATTR_CREATE | XATTR_REPLACE))) != 0); if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":553 * # Make sure we know all the flags * if flags & ~(xattr.XATTR_CREATE | xattr.XATTR_REPLACE): * raise ValueError('unknown flag(s): %o' % flags) # <<<<<<<<<<<<<< * * with lock: */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = PyUnicode_Format(__pyx_kp_u_unknown_flag_s_o, __pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } /* "src/llfuse/handlers.pxi":555 * raise ValueError('unknown flag(s): %o' % flags) * * with lock: # <<<<<<<<<<<<<< * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: */ /*with:*/ { __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_t_7, __pyx_n_s_exit); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_t_7, __pyx_n_s_enter); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L15_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (__pyx_t_10) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L15_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L15_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { /* "src/llfuse/handlers.pxi":556 * * with lock: * if flags & xattr.XATTR_CREATE: # Attribute must not exist # <<<<<<<<<<<<<< * try: * operations.getxattr(ino, name) */ __pyx_t_5 = ((__pyx_v_flags & XATTR_CREATE) != 0); if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":557 * with lock: * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: # <<<<<<<<<<<<<< * operations.getxattr(ino, name) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); /*try:*/ { /* "src/llfuse/handlers.pxi":558 * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: * operations.getxattr(ino, name) # <<<<<<<<<<<<<< * except FUSEError as e: * if e.errno != errno.ENOATTR: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_17 = 1; } } __pyx_t_18 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_18); if (__pyx_t_10) { PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = NULL; } PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_17, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_17, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_8 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_18, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } /*else:*/ { /* "src/llfuse/handlers.pxi":563 * raise * else: * raise FUSEError(errno.EEXIST) # <<<<<<<<<<<<<< * * elif flags & xattr.XATTR_REPLACE: # Attribute must exist */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_18 = __Pyx_PyInt_From_int(EEXIST); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_18); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (!__pyx_t_8) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_18); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_18); __Pyx_GIVEREF(__pyx_t_18); __pyx_t_18 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} } __pyx_L30_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":559 * try: * operations.getxattr(ino, name) * except FUSEError as e: # <<<<<<<<<<<<<< * if e.errno != errno.ENOATTR: * raise */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":560 * operations.getxattr(ino, name) * except FUSEError as e: * if e.errno != errno.ENOATTR: # <<<<<<<<<<<<<< * raise * else: */ __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_GOTREF(__pyx_t_18); __pyx_t_8 = __Pyx_PyInt_From_int(ENOATTR); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = PyObject_RichCompare(__pyx_t_18, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_20); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":561 * except FUSEError as e: * if e.errno != errno.ENOATTR: * raise # <<<<<<<<<<<<<< * else: * raise FUSEError(errno.EEXIST) */ __Pyx_GIVEREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_7, __pyx_t_4, __pyx_t_10); __pyx_t_7 = 0; __pyx_t_4 = 0; __pyx_t_10 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L43_error;} } } /* "src/llfuse/handlers.pxi":559 * try: * operations.getxattr(ino, name) * except FUSEError as e: # <<<<<<<<<<<<<< * if e.errno != errno.ENOATTR: * raise */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L44; } /*exception exit:*/{ __pyx_L43_error:; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_26, &__pyx_t_27, &__pyx_t_28); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25) < 0)) __Pyx_ErrFetch(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25); __Pyx_XGOTREF(__pyx_t_23); __Pyx_XGOTREF(__pyx_t_24); __Pyx_XGOTREF(__pyx_t_25); __Pyx_XGOTREF(__pyx_t_26); __Pyx_XGOTREF(__pyx_t_27); __Pyx_XGOTREF(__pyx_t_28); __pyx_t_19 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_26); __Pyx_XGIVEREF(__pyx_t_27); __Pyx_XGIVEREF(__pyx_t_28); __Pyx_ExceptionReset(__pyx_t_26, __pyx_t_27, __pyx_t_28); } __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ErrRestore(__pyx_t_23, __pyx_t_24, __pyx_t_25); __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L32_except_error; } __pyx_L44:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L31_exception_handled; } goto __pyx_L32_except_error; __pyx_L32_except_error:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); goto __pyx_L21_error; __pyx_L31_exception_handled:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } goto __pyx_L29; } /* "src/llfuse/handlers.pxi":565 * raise FUSEError(errno.EEXIST) * * elif flags & xattr.XATTR_REPLACE: # Attribute must exist # <<<<<<<<<<<<<< * operations.getxattr(ino, name) * */ __pyx_t_5 = ((__pyx_v_flags & XATTR_REPLACE) != 0); if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":566 * * elif flags & xattr.XATTR_REPLACE: # Attribute must exist * operations.getxattr(ino, name) # <<<<<<<<<<<<<< * * operations.setxattr(ino, name, value) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_20 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_17 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_20) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_17, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_17, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L29; } __pyx_L29:; /* "src/llfuse/handlers.pxi":568 * operations.getxattr(ino, name) * * operations.setxattr(ino, name, value) # <<<<<<<<<<<<<< * * ret = fuse_reply_err(req, 0) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_setxattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_17 = 1; } } __pyx_t_20 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_20); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } PyTuple_SET_ITEM(__pyx_t_20, 0+__pyx_t_17, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_20, 1+__pyx_t_17, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __Pyx_INCREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_20, 2+__pyx_t_17, __pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __pyx_t_8 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_20, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L28_try_end; __pyx_L21_error:; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/llfuse/handlers.pxi":555 * raise ValueError('unknown flag(s): %o' % flags) * * with lock: # <<<<<<<<<<<<<< * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_4, &__pyx_t_20) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_20); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_10, __pyx_t_4, __pyx_t_20); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_5 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __pyx_t_6 = ((!(__pyx_t_5 != 0)) != 0); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ErrRestore(__pyx_t_10, __pyx_t_4, __pyx_t_20); __pyx_t_10 = 0; __pyx_t_4 = 0; __pyx_t_20 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; goto __pyx_L22_exception_handled; } __pyx_L23_except_error:; __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); goto __pyx_L3_error; __pyx_L22_exception_handled:; __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_L28_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_9) { __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__26, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } goto __pyx_L20; } __pyx_L20:; } goto __pyx_L53; __pyx_L15_error:; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L3_error; __pyx_L53:; } } __pyx_L11:; /* "src/llfuse/handlers.pxi":570 * operations.setxattr(ino, name, value) * * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; /* "src/llfuse/handlers.pxi":571 * * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_20 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_20); __pyx_t_21 = PyErr_ExceptionMatches(__pyx_t_20); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_20, &__pyx_t_4, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_20); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_e, __pyx_t_4); /*try:*/ { /* "src/llfuse/handlers.pxi":572 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('setxattr', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L59_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_21 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L59_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_21); } /* "src/llfuse/handlers.pxi":571 * * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L60; } /*exception exit:*/{ __pyx_L59_error:; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_16, &__pyx_t_15); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_13, &__pyx_t_12) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_13, &__pyx_t_12); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_15); __pyx_t_21 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_29 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_16, __pyx_t_15); } __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_9, __pyx_t_13, __pyx_t_12); __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_lineno = __pyx_t_21; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_29; goto __pyx_L5_except_error; } __pyx_L60:; } __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":573 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setxattr', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_4, &__pyx_t_20) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 573; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_20); __Pyx_INCREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_e, __pyx_t_4); /*try:*/ { /* "src/llfuse/handlers.pxi":574 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('setxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_setxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":573 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L71; } __pyx_L71:; } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":576 * ret = handle_exc('setxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_6 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_6) { /* "src/llfuse/handlers.pxi":577 * * if ret != 0: * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * IF TARGET_PLATFORM == 'darwin': */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_18 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_18)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_18); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_18) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_30 = PyTuple_New(1+1); if (unlikely(!__pyx_t_30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_30); PyTuple_SET_ITEM(__pyx_t_30, 0, __pyx_t_18); __Pyx_GIVEREF(__pyx_t_18); __pyx_t_18 = NULL; PyTuple_SET_ITEM(__pyx_t_30, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_30, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_10))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_10, function); __pyx_t_17 = 1; } } __pyx_t_30 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_30); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_30, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_30, 0+__pyx_t_17, __pyx_kp_u_fuse_setxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_30, 1+__pyx_t_17, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_30, NULL); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_20); __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; goto __pyx_L72; } __pyx_L72:; /* "src/llfuse/handlers.pxi":534 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_18); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_30); __Pyx_WriteUnraisable("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":580 * * IF TARGET_PLATFORM == 'darwin': * cdef void fuse_getxattr_darwin (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size, uint32_t position) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_getxattr_darwin(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, size_t __pyx_v_size, uint32_t __pyx_v_position) { int __pyx_v_ret; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_getxattr_darwin", 0); /* "src/llfuse/handlers.pxi":584 * cdef int ret * * if position != 0: # <<<<<<<<<<<<<< * log.error('fuse_getxattr(): non-zero position (%d) not supported' % position) * ret = fuse_reply_err(req, errno.EIO) */ __pyx_t_1 = ((__pyx_v_position != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/handlers.pxi":585 * * if position != 0: * log.error('fuse_getxattr(): non-zero position (%d) not supported' % position) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, errno.EIO) * if ret != 0: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyInt_From_uint32_t(__pyx_v_position); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyUnicode_Format(__pyx_kp_u_fuse_getxattr_non_zero_position, __pyx_t_3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (!__pyx_t_3) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = NULL; PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/handlers.pxi":586 * if position != 0: * log.error('fuse_getxattr(): non-zero position (%d) not supported' % position) * ret = fuse_reply_err(req, errno.EIO) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, EIO); /* "src/llfuse/handlers.pxi":587 * log.error('fuse_getxattr(): non-zero position (%d) not supported' % position) * ret = fuse_reply_err(req, errno.EIO) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * else: */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/handlers.pxi":588 * ret = fuse_reply_err(req, errno.EIO) * if ret != 0: * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * else: * fuse_getxattr(req, ino, cname, size) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (!__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; __pyx_t_9 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_9 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_9, __pyx_kp_u_fuse_getxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_9, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L4; } __pyx_L4:; goto __pyx_L3; } /*else*/ { /* "src/llfuse/handlers.pxi":590 * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * else: * fuse_getxattr(req, ino, cname, size) # <<<<<<<<<<<<<< * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, */ __pyx_f_6llfuse_4capi_fuse_getxattr(__pyx_v_req, __pyx_v_ino, __pyx_v_cname, __pyx_v_size); } __pyx_L3:; /* "src/llfuse/handlers.pxi":580 * * IF TARGET_PLATFORM == 'darwin': * cdef void fuse_getxattr_darwin (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size, uint32_t position) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_WriteUnraisable("llfuse.capi.fuse_getxattr_darwin", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":592 * fuse_getxattr(req, ino, cname, size) * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_getxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, size_t __pyx_v_size) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_getxattr", 0); /* "src/llfuse/handlers.pxi":597 * cdef ssize_t len_ * cdef char *cbuf * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":598 * cdef char *cbuf * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * buf = operations.getxattr(ino, name) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 598; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":600 * name = PyBytes_FromString(cname) * with lock: * buf = operations.getxattr(ino, name) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_13); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_13 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__27, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":601 * with lock: * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * * if size == 0: */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 601; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_17 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_17 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 601; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":603 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * * if size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: */ __pyx_t_16 = ((__pyx_v_size == 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":604 * * if size == 0: * ret = fuse_reply_xattr(req, len_) # <<<<<<<<<<<<<< * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_v_ret = fuse_reply_xattr(__pyx_v_req, __pyx_v_len_); goto __pyx_L29; } /* "src/llfuse/handlers.pxi":605 * if size == 0: * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * else: */ __pyx_t_16 = ((((size_t)__pyx_v_len_) <= __pyx_v_size) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":606 * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, errno.ERANGE) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); goto __pyx_L29; } /*else*/ { /* "src/llfuse/handlers.pxi":608 * ret = fuse_reply_buf(req, cbuf, len_) * else: * ret = fuse_reply_err(req, errno.ERANGE) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, ERANGE); } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; /* "src/llfuse/handlers.pxi":609 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":610 * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('getxattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 610; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 610; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":609 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":611 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getxattr', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 611; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":612 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('getxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_getxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":611 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L47; } __pyx_L47:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":614 * ret = handle_exc('getxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":615 * * if ret != 0: * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_12, __pyx_kp_u_fuse_getxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L48; } __pyx_L48:; /* "src/llfuse/handlers.pxi":592 * fuse_getxattr(req, ino, cname, size) * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":617 * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_ */ static void __pyx_f_6llfuse_4capi_fuse_listxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, size_t __pyx_v_size) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_listxattr", 0); /* "src/llfuse/handlers.pxi":621 * cdef ssize_t len_ * cdef char *cbuf * try: # <<<<<<<<<<<<<< * with lock: * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":623 * try: * with lock: * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' # <<<<<<<<<<<<<< * * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_listxattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyBytes_Join(__pyx_kp_b__28, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyNumber_Add(__pyx_t_6, __pyx_kp_b__28); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__29, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":625 * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * * if len_ == 1: # No attributes */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_16 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":627 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * * if len_ == 1: # No attributes # <<<<<<<<<<<<<< * len_ = 0 * */ __pyx_t_15 = ((__pyx_v_len_ == 1) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":628 * * if len_ == 1: # No attributes * len_ = 0 # <<<<<<<<<<<<<< * * if size == 0: */ __pyx_v_len_ = 0; goto __pyx_L29; } __pyx_L29:; /* "src/llfuse/handlers.pxi":630 * len_ = 0 * * if size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: */ __pyx_t_15 = ((__pyx_v_size == 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":631 * * if size == 0: * ret = fuse_reply_xattr(req, len_) # <<<<<<<<<<<<<< * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_v_ret = fuse_reply_xattr(__pyx_v_req, __pyx_v_len_); goto __pyx_L30; } /* "src/llfuse/handlers.pxi":632 * if size == 0: * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * else: */ __pyx_t_15 = ((((size_t)__pyx_v_len_) <= __pyx_v_size) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":633 * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, errno.ERANGE) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); goto __pyx_L30; } /*else*/ { /* "src/llfuse/handlers.pxi":635 * ret = fuse_reply_buf(req, cbuf, len_) * else: * ret = fuse_reply_err(req, errno.ERANGE) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, ERANGE); } __pyx_L30:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":636 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":637 * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('listxattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":636 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L37; } /*exception exit:*/{ __pyx_L36_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L37:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":638 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('listxattr', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":639 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('listxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_listxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":638 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('listxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":641 * ret = handle_exc('listxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":642 * * if ret != 0: * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_listxattr_fuse_reply__faile); __Pyx_GIVEREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L49; } __pyx_L49:; /* "src/llfuse/handlers.pxi":617 * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_ */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":644 * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: # <<<<<<<<<<<<<< * cdef int ret * try: */ static void __pyx_f_6llfuse_4capi_fuse_removexattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname) { int __pyx_v_ret; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_removexattr", 0); /* "src/llfuse/handlers.pxi":646 * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: * cdef int ret * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":647 * cdef int ret * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * operations.removexattr(ino, name) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":649 * name = PyBytes_FromString(cname) * with lock: * operations.removexattr(ino, name) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_removexattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_13); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_13 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__30, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":650 * with lock: * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; /* "src/llfuse/handlers.pxi":651 * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":652 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('removexattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":651 * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":653 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('removexattr', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":654 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('removexattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_removexattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":653 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('removexattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":656 * ret = handle_exc('removexattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":657 * * if ret != 0: * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_12, __pyx_kp_u_fuse_removexattr_fuse_reply__fai); __Pyx_GIVEREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":644 * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: # <<<<<<<<<<<<<< * cdef int ret * try: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":659 * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_access(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, int __pyx_v_mask) { int __pyx_v_ret; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_allowed = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_access", 0); /* "src/llfuse/handlers.pxi":662 * cdef int ret * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":663 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * allowed = operations.access(ino, mask, ctx) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":665 * ctx = get_request_context(req) * with lock: * allowed = operations.access(ino, mask, ctx) # <<<<<<<<<<<<<< * if allowed: * ret = fuse_reply_err(req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_access); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_mask); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_allowed = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__31, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":666 * with lock: * allowed = operations.access(ino, mask, ctx) * if allowed: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * else: */ if (unlikely(!__pyx_v_allowed)) { __Pyx_RaiseUnboundLocalError("allowed"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_allowed); if (unlikely(__pyx_t_17 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":667 * allowed = operations.access(ino, mask, ctx) * if allowed: * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, EPERM) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); goto __pyx_L29; } /*else*/ { /* "src/llfuse/handlers.pxi":669 * ret = fuse_reply_err(req, 0) * else: * ret = fuse_reply_err(req, EPERM) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, EPERM); } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":670 * else: * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":671 * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('access', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":670 * else: * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":672 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('access', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":673 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('access', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_access, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":672 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('access', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L47; } __pyx_L47:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":675 * ret = handle_exc('access', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":676 * * if ret != 0: * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_access_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L48; } __pyx_L48:; /* "src/llfuse/handlers.pxi":659 * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_allowed); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":679 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *cname, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_create(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_cname, mode_t __pyx_v_mode, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *(*__pyx_t_16)(PyObject *); uint64_t __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; int __pyx_t_22; char const *__pyx_t_23; PyObject *__pyx_t_24 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_create", 0); /* "src/llfuse/handlers.pxi":684 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * name = PyBytes_FromString(cname) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":685 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":686 * try: * ctx = get_request_context(req) * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":688 * name = PyBytes_FromString(cname) * with lock: * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) # <<<<<<<<<<<<<< * * # Cached file data does not need to be invalidated. */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_create); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_fi->flags); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(5+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 4+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { PyObject* sequence = __pyx_t_4; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_6 = PyList_GET_ITEM(sequence, 0); __pyx_t_15 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_15); #else __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); #endif __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { Py_ssize_t index = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_16 = Py_TYPE(__pyx_t_12)->tp_iternext; index = 0; __pyx_t_6 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_6)) goto __pyx_L25_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); index = 1; __pyx_t_15 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_15)) goto __pyx_L25_unpacking_failed; __Pyx_GOTREF(__pyx_t_15); if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_12), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __pyx_t_16 = NULL; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L26_unpacking_done; __pyx_L25_unpacking_failed:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_16 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __pyx_L26_unpacking_done:; } __pyx_t_17 = __Pyx_PyInt_As_uint64_t(__pyx_t_6); if (unlikely((__pyx_t_17 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_fi->fh = __pyx_t_17; __pyx_v_attr = __pyx_t_15; __pyx_t_15 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_15, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_15, __pyx_t_6); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_18); __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_18); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; if (__pyx_t_19 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_20 = ((!(__pyx_t_19 != 0)) != 0); if (__pyx_t_20) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_15, __pyx_t_6); __pyx_t_4 = 0; __pyx_t_15 = 0; __pyx_t_6 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__32, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L30; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L30:; } /* "src/llfuse/handlers.pxi":692 * # Cached file data does not need to be invalidated. * # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ * fi.keep_cache = 1 # <<<<<<<<<<<<<< * * fill_entry_param(attr, &entry) */ __pyx_v_fi->keep_cache = 1; /* "src/llfuse/handlers.pxi":694 * fi.keep_cache = 1 * * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_6 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":695 * * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_create(__pyx_v_req, (&__pyx_v_entry), __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":696 * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_21 = PyErr_ExceptionMatches(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_15, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_15); __pyx_v_e = __pyx_t_15; /*try:*/ { /* "src/llfuse/handlers.pxi":697 * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('create', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_21 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_21 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_21); } /* "src/llfuse/handlers.pxi":696 * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L37; } /*exception exit:*/{ __pyx_L36_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_18 = 0; __pyx_t_24 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_18, &__pyx_t_24); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_24); __pyx_t_21 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_23 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_18, __pyx_t_24); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_18 = 0; __pyx_t_24 = 0; __pyx_lineno = __pyx_t_21; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_23; goto __pyx_L5_except_error; } __pyx_L37:; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":698 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('create', e, req) * */ __pyx_t_22 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_22) { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_15, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_15); __pyx_v_e = __pyx_t_15; /*try:*/ { /* "src/llfuse/handlers.pxi":699 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('create', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_create, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":698 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('create', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":701 * ret = handle_exc('create', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) */ __pyx_t_20 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/llfuse/handlers.pxi":702 * * if ret != 0: * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_15); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_create_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_15); __Pyx_GIVEREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L49; } __pyx_L49:; /* "src/llfuse/handlers.pxi":679 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *cname, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/misc.pxi":13 * ''' * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): # <<<<<<<<<<<<<< * entry.ino = attr.st_ino * entry.generation = attr.generation */ static PyObject *__pyx_f_6llfuse_4capi_fill_entry_param(PyObject *__pyx_v_attr, struct fuse_entry_param *__pyx_v_entry) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; fuse_ino_t __pyx_t_2; unsigned long __pyx_t_3; double __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_entry_param", 0); /* "src/llfuse/misc.pxi":14 * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): * entry.ino = attr.st_ino # <<<<<<<<<<<<<< * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ino); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->ino = __pyx_t_2; /* "src/llfuse/misc.pxi":15 * cdef object fill_entry_param(object attr, fuse_entry_param* entry): * entry.ino = attr.st_ino * entry.generation = attr.generation # <<<<<<<<<<<<<< * entry.entry_timeout = attr.entry_timeout * entry.attr_timeout = attr.attr_timeout */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_generation); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_unsigned_long(__pyx_t_1); if (unlikely((__pyx_t_3 == (unsigned long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->generation = __pyx_t_3; /* "src/llfuse/misc.pxi":16 * entry.ino = attr.st_ino * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout # <<<<<<<<<<<<<< * entry.attr_timeout = attr.attr_timeout * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_entry_timeout); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->entry_timeout = __pyx_t_4; /* "src/llfuse/misc.pxi":17 * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout * entry.attr_timeout = attr.attr_timeout # <<<<<<<<<<<<<< * * fill_c_stat(attr, &entry.attr) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->attr_timeout = __pyx_t_4; /* "src/llfuse/misc.pxi":19 * entry.attr_timeout = attr.attr_timeout * * fill_c_stat(attr, &entry.attr) # <<<<<<<<<<<<<< * * cdef object fill_c_stat(object attr, c_stat* stat): */ __pyx_t_1 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_entry->attr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 19; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":13 * ''' * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): # <<<<<<<<<<<<<< * entry.ino = attr.st_ino * entry.generation = attr.generation */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.fill_entry_param", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":21 * fill_c_stat(attr, &entry.attr) * * cdef object fill_c_stat(object attr, c_stat* stat): # <<<<<<<<<<<<<< * * # Under OS-X, c_stat has an additional st_flags field. The memset */ static PyObject *__pyx_f_6llfuse_4capi_fill_c_stat(PyObject *__pyx_v_attr, struct stat *__pyx_v_stat) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; ino_t __pyx_t_2; mode_t __pyx_t_3; nlink_t __pyx_t_4; uid_t __pyx_t_5; gid_t __pyx_t_6; dev_t __pyx_t_7; off_t __pyx_t_8; blksize_t __pyx_t_9; blkcnt_t __pyx_t_10; int __pyx_t_11; int __pyx_t_12; PyObject *__pyx_t_13 = NULL; time_t __pyx_t_14; long __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_c_stat", 0); /* "src/llfuse/misc.pxi":27 * # platform check (although, admittedly, this explanatory comment * # make take even more space than the check would have taken). * string.memset(stat, 0, sizeof(c_stat)) # <<<<<<<<<<<<<< * * stat.st_ino = attr.st_ino */ memset(__pyx_v_stat, 0, (sizeof(struct stat))); /* "src/llfuse/misc.pxi":29 * string.memset(stat, 0, sizeof(c_stat)) * * stat.st_ino = attr.st_ino # <<<<<<<<<<<<<< * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ino); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_ino_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_ino = __pyx_t_2; /* "src/llfuse/misc.pxi":30 * * stat.st_ino = attr.st_ino * stat.st_mode = attr.st_mode # <<<<<<<<<<<<<< * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_mode_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (mode_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_mode = __pyx_t_3; /* "src/llfuse/misc.pxi":31 * stat.st_ino = attr.st_ino * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink # <<<<<<<<<<<<<< * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_nlink); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_nlink_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (nlink_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_nlink = __pyx_t_4; /* "src/llfuse/misc.pxi":32 * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid # <<<<<<<<<<<<<< * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyInt_As_uid_t(__pyx_t_1); if (unlikely((__pyx_t_5 == (uid_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_uid = __pyx_t_5; /* "src/llfuse/misc.pxi":33 * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid # <<<<<<<<<<<<<< * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_gid_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (gid_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_gid = __pyx_t_6; /* "src/llfuse/misc.pxi":34 * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev # <<<<<<<<<<<<<< * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_rdev); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyInt_As_dev_t(__pyx_t_1); if (unlikely((__pyx_t_7 == (dev_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_rdev = __pyx_t_7; /* "src/llfuse/misc.pxi":35 * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size # <<<<<<<<<<<<<< * stat.st_blksize = attr.st_blksize * stat.st_blocks = attr.st_blocks */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_size); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyInt_As_off_t(__pyx_t_1); if (unlikely((__pyx_t_8 == (off_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_size = __pyx_t_8; /* "src/llfuse/misc.pxi":36 * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize # <<<<<<<<<<<<<< * stat.st_blocks = attr.st_blocks * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_blksize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyInt_As_blksize_t(__pyx_t_1); if (unlikely((__pyx_t_9 == (blksize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_blksize = __pyx_t_9; /* "src/llfuse/misc.pxi":37 * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize * stat.st_blocks = attr.st_blocks # <<<<<<<<<<<<<< * * if attr.st_atime_ns is not None: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_blocks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyInt_As_blkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_10 == (blkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_blocks = __pyx_t_10; /* "src/llfuse/misc.pxi":39 * stat.st_blocks = attr.st_blocks * * if attr.st_atime_ns is not None: # <<<<<<<<<<<<<< * stat.st_atime = attr.st_atime_ns / 10**9 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_12 = (__pyx_t_11 != 0); if (__pyx_t_12) { /* "src/llfuse/misc.pxi":40 * * if attr.st_atime_ns is not None: * stat.st_atime = attr.st_atime_ns / 10**9 # <<<<<<<<<<<<<< * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) * else: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_int_1000000000); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_13); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_stat->st_atime = __pyx_t_14; /* "src/llfuse/misc.pxi":41 * if attr.st_atime_ns is not None: * stat.st_atime = attr.st_atime_ns / 10**9 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_atime = attr.st_atime */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_1 = PyNumber_Remainder(__pyx_t_13, __pyx_int_1000000000); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_ATIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":43 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) * else: * stat.st_atime = attr.st_atime # <<<<<<<<<<<<<< * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_1); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_atime = __pyx_t_14; /* "src/llfuse/misc.pxi":44 * else: * stat.st_atime = attr.st_atime * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) # <<<<<<<<<<<<<< * * if attr.st_ctime_ns is not None: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_atime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = PyNumber_Subtract(__pyx_t_1, __pyx_t_13); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = PyNumber_Multiply(__pyx_t_16, __pyx_float_1e9); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_13); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; SET_ATIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L3:; /* "src/llfuse/misc.pxi":46 * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) * * if attr.st_ctime_ns is not None: # <<<<<<<<<<<<<< * stat.st_ctime = attr.st_ctime_ns / 10**9 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = (__pyx_t_13 != Py_None); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_11 = (__pyx_t_12 != 0); if (__pyx_t_11) { /* "src/llfuse/misc.pxi":47 * * if attr.st_ctime_ns is not None: * stat.st_ctime = attr.st_ctime_ns / 10**9 # <<<<<<<<<<<<<< * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) * else: */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = __Pyx_PyNumber_Divide(__pyx_t_13, __pyx_int_1000000000); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_16); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_v_stat->st_ctime = __pyx_t_14; /* "src/llfuse/misc.pxi":48 * if attr.st_ctime_ns is not None: * stat.st_ctime = attr.st_ctime_ns / 10**9 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_ctime = attr.st_ctime */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyNumber_Remainder(__pyx_t_16, __pyx_int_1000000000); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_13); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; SET_CTIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L4; } /*else*/ { /* "src/llfuse/misc.pxi":50 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) * else: * stat.st_ctime = attr.st_ctime # <<<<<<<<<<<<<< * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) * */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_13); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_stat->st_ctime = __pyx_t_14; /* "src/llfuse/misc.pxi":51 * else: * stat.st_ctime = attr.st_ctime * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) # <<<<<<<<<<<<<< * * if attr.st_mtime_ns is not None: */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_ctime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = PyNumber_Subtract(__pyx_t_13, __pyx_t_16); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = PyNumber_Multiply(__pyx_t_1, __pyx_float_1e9); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_16); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; SET_CTIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L4:; /* "src/llfuse/misc.pxi":53 * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) * * if attr.st_mtime_ns is not None: # <<<<<<<<<<<<<< * stat.st_mtime = attr.st_mtime_ns / 10**9 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 53; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_11 = (__pyx_t_16 != Py_None); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_12 = (__pyx_t_11 != 0); if (__pyx_t_12) { /* "src/llfuse/misc.pxi":54 * * if attr.st_mtime_ns is not None: * stat.st_mtime = attr.st_mtime_ns / 10**9 # <<<<<<<<<<<<<< * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) * else: */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_16, __pyx_int_1000000000); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_1); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_mtime = __pyx_t_14; /* "src/llfuse/misc.pxi":55 * if attr.st_mtime_ns is not None: * stat.st_mtime = attr.st_mtime_ns / 10**9 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_mtime = attr.st_mtime */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_16 = PyNumber_Remainder(__pyx_t_1, __pyx_int_1000000000); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_16); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; SET_MTIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L5; } /*else*/ { /* "src/llfuse/misc.pxi":57 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) * else: * stat.st_mtime = attr.st_mtime # <<<<<<<<<<<<<< * SET_MTIME_NS(stat, (attr.st_mtime - stat.st_mtime) * 1e9) * */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_16); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_v_stat->st_mtime = __pyx_t_14; /* "src/llfuse/misc.pxi":58 * else: * stat.st_mtime = attr.st_mtime * SET_MTIME_NS(stat, (attr.st_mtime - stat.st_mtime) * 1e9) # <<<<<<<<<<<<<< * * */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_mtime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyNumber_Subtract(__pyx_t_16, __pyx_t_1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyNumber_Multiply(__pyx_t_13, __pyx_float_1e9); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_MTIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L5:; /* "src/llfuse/misc.pxi":21 * fill_c_stat(attr, &entry.attr) * * cdef object fill_c_stat(object attr, c_stat* stat): # <<<<<<<<<<<<<< * * # Under OS-X, c_stat has an additional st_flags field. The memset */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_16); __Pyx_AddTraceback("llfuse.capi.fill_c_stat", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":61 * * * cdef object fill_statvfs(object attr, statvfs* stat): # <<<<<<<<<<<<<< * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize */ static PyObject *__pyx_f_6llfuse_4capi_fill_statvfs(PyObject *__pyx_v_attr, struct statvfs *__pyx_v_stat) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; fsblkcnt_t __pyx_t_3; fsfilcnt_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_statvfs", 0); /* "src/llfuse/misc.pxi":62 * * cdef object fill_statvfs(object attr, statvfs* stat): * stat.f_bsize = attr.f_bsize # <<<<<<<<<<<<<< * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 62; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 62; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bsize = __pyx_t_2; /* "src/llfuse/misc.pxi":63 * cdef object fill_statvfs(object attr, statvfs* stat): * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize # <<<<<<<<<<<<<< * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_frsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_frsize = __pyx_t_2; /* "src/llfuse/misc.pxi":64 * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks # <<<<<<<<<<<<<< * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_blocks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 64; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 64; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_blocks = __pyx_t_3; /* "src/llfuse/misc.pxi":65 * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree # <<<<<<<<<<<<<< * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bfree); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 65; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 65; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bfree = __pyx_t_3; /* "src/llfuse/misc.pxi":66 * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail # <<<<<<<<<<<<<< * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bavail); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bavail = __pyx_t_3; /* "src/llfuse/misc.pxi":67 * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files # <<<<<<<<<<<<<< * stat.f_ffree = attr.f_ffree * stat.f_favail = attr.f_favail */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_files); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 67; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 67; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_files = __pyx_t_4; /* "src/llfuse/misc.pxi":68 * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree # <<<<<<<<<<<<<< * stat.f_favail = attr.f_favail * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_ffree); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 68; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 68; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_ffree = __pyx_t_4; /* "src/llfuse/misc.pxi":69 * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree * stat.f_favail = attr.f_favail # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_favail); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_favail = __pyx_t_4; /* "src/llfuse/misc.pxi":61 * * * cdef object fill_statvfs(object attr, statvfs* stat): # <<<<<<<<<<<<<< * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.fill_statvfs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":72 * * * cdef int handle_exc(char* fn, object e, fuse_req_t req): # <<<<<<<<<<<<<< * '''Try to call fuse_reply_err and terminate main loop''' * */ static int __pyx_f_6llfuse_4capi_handle_exc(CYTHON_UNUSED char *__pyx_v_fn, CYTHON_UNUSED PyObject *__pyx_v_e, fuse_req_t __pyx_v_req) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("handle_exc", 0); /* "src/llfuse/misc.pxi":77 * global exc_info * * if not exc_info: # <<<<<<<<<<<<<< * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":78 * * if not exc_info: * exc_info = sys.exc_info() # <<<<<<<<<<<<<< * log.debug('handler raised exception, sending SIGTERM to self.') * kill(getpid(), SIGTERM) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_4) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":79 * if not exc_info: * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') # <<<<<<<<<<<<<< * kill(getpid(), SIGTERM) * else: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":80 * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') * kill(getpid(), SIGTERM) # <<<<<<<<<<<<<< * else: * log.exception('Exception after kill:') */ kill(getpid(), SIGTERM); goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":82 * kill(getpid(), SIGTERM) * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * if req is NULL: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_exception); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "src/llfuse/misc.pxi":84 * log.exception('Exception after kill:') * * if req is NULL: # <<<<<<<<<<<<<< * return 0 * else: */ __pyx_t_2 = ((__pyx_v_req == NULL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":85 * * if req is NULL: * return 0 # <<<<<<<<<<<<<< * else: * return fuse_reply_err(req, errno.EIO) */ __pyx_r = 0; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":87 * return 0 * else: * return fuse_reply_err(req, errno.EIO) # <<<<<<<<<<<<<< * * cdef object get_request_context(fuse_req_t req): */ __pyx_r = fuse_reply_err(__pyx_v_req, EIO); goto __pyx_L0; } /* "src/llfuse/misc.pxi":72 * * * cdef int handle_exc(char* fn, object e, fuse_req_t req): # <<<<<<<<<<<<<< * '''Try to call fuse_reply_err and terminate main loop''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("llfuse.capi.handle_exc", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":89 * return fuse_reply_err(req, errno.EIO) * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ static PyObject *__pyx_f_6llfuse_4capi_get_request_context(fuse_req_t __pyx_v_req) { const struct fuse_ctx *__pyx_v_context; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_request_context", 0); /* "src/llfuse/misc.pxi":94 * cdef const_fuse_ctx* context * * context = fuse_req_ctx(req) # <<<<<<<<<<<<<< * ctx = RequestContext() * ctx.pid = context.pid */ __pyx_v_context = fuse_req_ctx(__pyx_v_req); /* "src/llfuse/misc.pxi":95 * * context = fuse_req_ctx(req) * ctx = RequestContext() # <<<<<<<<<<<<<< * ctx.pid = context.pid * ctx.uid = context.uid */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_RequestContext); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":96 * context = fuse_req_ctx(req) * ctx = RequestContext() * ctx.pid = context.pid # <<<<<<<<<<<<<< * ctx.uid = context.uid * ctx.gid = context.gid */ __pyx_t_1 = __Pyx_PyInt_From_pid_t(__pyx_v_context->pid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_pid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":97 * ctx = RequestContext() * ctx.pid = context.pid * ctx.uid = context.uid # <<<<<<<<<<<<<< * ctx.gid = context.gid * ctx.umask = context.umask */ __pyx_t_1 = __Pyx_PyInt_From_uid_t(__pyx_v_context->uid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 97; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_uid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 97; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":98 * ctx.pid = context.pid * ctx.uid = context.uid * ctx.gid = context.gid # <<<<<<<<<<<<<< * ctx.umask = context.umask * */ __pyx_t_1 = __Pyx_PyInt_From_gid_t(__pyx_v_context->gid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_gid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":99 * ctx.uid = context.uid * ctx.gid = context.gid * ctx.umask = context.umask # <<<<<<<<<<<<<< * * return ctx */ __pyx_t_1 = __Pyx_PyInt_From_mode_t(__pyx_v_context->umask); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_umask, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":101 * ctx.umask = context.umask * * return ctx # <<<<<<<<<<<<<< * * cdef void init_fuse_ops(): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ctx); __pyx_r = __pyx_v_ctx; goto __pyx_L0; /* "src/llfuse/misc.pxi":89 * return fuse_reply_err(req, errno.EIO) * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.get_request_context", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":103 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ static void __pyx_f_6llfuse_4capi_init_fuse_ops(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init_fuse_ops", 0); /* "src/llfuse/misc.pxi":106 * '''Initialize fuse_lowlevel_ops structure''' * * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) # <<<<<<<<<<<<<< * * fuse_ops.init = fuse_init */ memset((&__pyx_v_6llfuse_4capi_fuse_ops), 0, (sizeof(struct fuse_lowlevel_ops))); /* "src/llfuse/misc.pxi":108 * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) * * fuse_ops.init = fuse_init # <<<<<<<<<<<<<< * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup */ __pyx_v_6llfuse_4capi_fuse_ops.init = __pyx_f_6llfuse_4capi_fuse_init; /* "src/llfuse/misc.pxi":109 * * fuse_ops.init = fuse_init * fuse_ops.destroy = fuse_destroy # <<<<<<<<<<<<<< * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget */ __pyx_v_6llfuse_4capi_fuse_ops.destroy = __pyx_f_6llfuse_4capi_fuse_destroy; /* "src/llfuse/misc.pxi":110 * fuse_ops.init = fuse_init * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup # <<<<<<<<<<<<<< * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr */ __pyx_v_6llfuse_4capi_fuse_ops.lookup = __pyx_f_6llfuse_4capi_fuse_lookup; /* "src/llfuse/misc.pxi":111 * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget # <<<<<<<<<<<<<< * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr */ __pyx_v_6llfuse_4capi_fuse_ops.forget = __pyx_f_6llfuse_4capi_fuse_forget; /* "src/llfuse/misc.pxi":112 * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr # <<<<<<<<<<<<<< * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink */ __pyx_v_6llfuse_4capi_fuse_ops.getattr = __pyx_f_6llfuse_4capi_fuse_getattr; /* "src/llfuse/misc.pxi":113 * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr # <<<<<<<<<<<<<< * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod */ __pyx_v_6llfuse_4capi_fuse_ops.setattr = __pyx_f_6llfuse_4capi_fuse_setattr; /* "src/llfuse/misc.pxi":114 * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink # <<<<<<<<<<<<<< * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir */ __pyx_v_6llfuse_4capi_fuse_ops.readlink = __pyx_f_6llfuse_4capi_fuse_readlink; /* "src/llfuse/misc.pxi":115 * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod # <<<<<<<<<<<<<< * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink */ __pyx_v_6llfuse_4capi_fuse_ops.mknod = __pyx_f_6llfuse_4capi_fuse_mknod; /* "src/llfuse/misc.pxi":116 * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir # <<<<<<<<<<<<<< * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir */ __pyx_v_6llfuse_4capi_fuse_ops.mkdir = __pyx_f_6llfuse_4capi_fuse_mkdir; /* "src/llfuse/misc.pxi":117 * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink # <<<<<<<<<<<<<< * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink */ __pyx_v_6llfuse_4capi_fuse_ops.unlink = __pyx_f_6llfuse_4capi_fuse_unlink; /* "src/llfuse/misc.pxi":118 * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir # <<<<<<<<<<<<<< * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename */ __pyx_v_6llfuse_4capi_fuse_ops.rmdir = __pyx_f_6llfuse_4capi_fuse_rmdir; /* "src/llfuse/misc.pxi":119 * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink # <<<<<<<<<<<<<< * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link */ __pyx_v_6llfuse_4capi_fuse_ops.symlink = __pyx_f_6llfuse_4capi_fuse_symlink; /* "src/llfuse/misc.pxi":120 * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename # <<<<<<<<<<<<<< * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open */ __pyx_v_6llfuse_4capi_fuse_ops.rename = __pyx_f_6llfuse_4capi_fuse_rename; /* "src/llfuse/misc.pxi":121 * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link # <<<<<<<<<<<<<< * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read */ __pyx_v_6llfuse_4capi_fuse_ops.link = __pyx_f_6llfuse_4capi_fuse_link; /* "src/llfuse/misc.pxi":122 * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open # <<<<<<<<<<<<<< * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write */ __pyx_v_6llfuse_4capi_fuse_ops.open = __pyx_f_6llfuse_4capi_fuse_open; /* "src/llfuse/misc.pxi":123 * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read # <<<<<<<<<<<<<< * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush */ __pyx_v_6llfuse_4capi_fuse_ops.read = __pyx_f_6llfuse_4capi_fuse_read; /* "src/llfuse/misc.pxi":124 * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write # <<<<<<<<<<<<<< * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release */ __pyx_v_6llfuse_4capi_fuse_ops.write = __pyx_f_6llfuse_4capi_fuse_write; /* "src/llfuse/misc.pxi":125 * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush # <<<<<<<<<<<<<< * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync */ __pyx_v_6llfuse_4capi_fuse_ops.flush = __pyx_f_6llfuse_4capi_fuse_flush; /* "src/llfuse/misc.pxi":126 * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release # <<<<<<<<<<<<<< * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir */ __pyx_v_6llfuse_4capi_fuse_ops.release = __pyx_f_6llfuse_4capi_fuse_release; /* "src/llfuse/misc.pxi":127 * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync # <<<<<<<<<<<<<< * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir */ __pyx_v_6llfuse_4capi_fuse_ops.fsync = __pyx_f_6llfuse_4capi_fuse_fsync; /* "src/llfuse/misc.pxi":128 * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir # <<<<<<<<<<<<<< * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir */ __pyx_v_6llfuse_4capi_fuse_ops.opendir = __pyx_f_6llfuse_4capi_fuse_opendir; /* "src/llfuse/misc.pxi":129 * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir # <<<<<<<<<<<<<< * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir */ __pyx_v_6llfuse_4capi_fuse_ops.readdir = __pyx_f_6llfuse_4capi_fuse_readdir; /* "src/llfuse/misc.pxi":130 * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir # <<<<<<<<<<<<<< * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs */ __pyx_v_6llfuse_4capi_fuse_ops.releasedir = __pyx_f_6llfuse_4capi_fuse_releasedir; /* "src/llfuse/misc.pxi":131 * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir # <<<<<<<<<<<<<< * fuse_ops.statfs = fuse_statfs * IF TARGET_PLATFORM == 'darwin': */ __pyx_v_6llfuse_4capi_fuse_ops.fsyncdir = __pyx_f_6llfuse_4capi_fuse_fsyncdir; /* "src/llfuse/misc.pxi":132 * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'darwin': * fuse_ops.setxattr = fuse_setxattr_darwin */ __pyx_v_6llfuse_4capi_fuse_ops.statfs = __pyx_f_6llfuse_4capi_fuse_statfs; /* "src/llfuse/misc.pxi":134 * fuse_ops.statfs = fuse_statfs * IF TARGET_PLATFORM == 'darwin': * fuse_ops.setxattr = fuse_setxattr_darwin # <<<<<<<<<<<<<< * fuse_ops.getxattr = fuse_getxattr_darwin * ELSE: */ __pyx_v_6llfuse_4capi_fuse_ops.setxattr = __pyx_f_6llfuse_4capi_fuse_setxattr_darwin; /* "src/llfuse/misc.pxi":135 * IF TARGET_PLATFORM == 'darwin': * fuse_ops.setxattr = fuse_setxattr_darwin * fuse_ops.getxattr = fuse_getxattr_darwin # <<<<<<<<<<<<<< * ELSE: * fuse_ops.setxattr = fuse_setxattr */ __pyx_v_6llfuse_4capi_fuse_ops.getxattr = __pyx_f_6llfuse_4capi_fuse_getxattr_darwin; /* "src/llfuse/misc.pxi":139 * fuse_ops.setxattr = fuse_setxattr * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr # <<<<<<<<<<<<<< * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access */ __pyx_v_6llfuse_4capi_fuse_ops.listxattr = __pyx_f_6llfuse_4capi_fuse_listxattr; /* "src/llfuse/misc.pxi":140 * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr # <<<<<<<<<<<<<< * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create */ __pyx_v_6llfuse_4capi_fuse_ops.removexattr = __pyx_f_6llfuse_4capi_fuse_removexattr; /* "src/llfuse/misc.pxi":141 * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access # <<<<<<<<<<<<<< * fuse_ops.create = fuse_create * */ __pyx_v_6llfuse_4capi_fuse_ops.access = __pyx_f_6llfuse_4capi_fuse_access; /* "src/llfuse/misc.pxi":142 * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create # <<<<<<<<<<<<<< * * cdef make_fuse_args(list args, fuse_args* f_args): */ __pyx_v_6llfuse_4capi_fuse_ops.create = __pyx_f_6llfuse_4capi_fuse_create; /* "src/llfuse/misc.pxi":103 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "src/llfuse/misc.pxi":144 * fuse_ops.create = fuse_create * * cdef make_fuse_args(list args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ static PyObject *__pyx_f_6llfuse_4capi_make_fuse_args(PyObject *__pyx_v_args, struct fuse_args *__pyx_v_f_args) { char *__pyx_v_arg; int __pyx_v_i; Py_ssize_t __pyx_v_size; PyObject *__pyx_v_args_new = NULL; PyObject *__pyx_v_el = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; int __pyx_t_13; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("make_fuse_args", 0); __Pyx_INCREF(__pyx_v_args); /* "src/llfuse/misc.pxi":149 * cdef ssize_t size * * args_new = [ b'Python-LLFUSE' ] # <<<<<<<<<<<<<< * for el in args: * if not isinstance(el, str_t): */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_b_Python_LLFUSE); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_kp_b_Python_LLFUSE); __Pyx_GIVEREF(__pyx_kp_b_Python_LLFUSE); __pyx_v_args_new = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":150 * * args_new = [ b'Python-LLFUSE' ] * for el in args: # <<<<<<<<<<<<<< * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') */ if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":151 * args_new = [ b'Python-LLFUSE' ] * for el in args: * if not isinstance(el, str_t): # <<<<<<<<<<<<<< * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_IsInstance(__pyx_v_el, __pyx_t_3); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":152 * for el in args: * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":153 * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') # <<<<<<<<<<<<<< * args_new.append(el.encode('us-ascii')) * args = args_new */ __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_kp_b_o); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 153; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":154 * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) # <<<<<<<<<<<<<< * args = args_new * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_el, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_t_7); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/misc.pxi":150 * * args_new = [ b'Python-LLFUSE' ] * for el in args: # <<<<<<<<<<<<<< * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":155 * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) * args = args_new # <<<<<<<<<<<<<< * * f_args.argc = len(args) */ __Pyx_INCREF(__pyx_v_args_new); __Pyx_DECREF_SET(__pyx_v_args, __pyx_v_args_new); /* "src/llfuse/misc.pxi":157 * args = args_new * * f_args.argc = len(args) # <<<<<<<<<<<<<< * if f_args.argc == 0: * f_args.argv = NULL */ __pyx_t_2 = PyList_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_f_args->argc = ((int)__pyx_t_2); /* "src/llfuse/misc.pxi":158 * * f_args.argc = len(args) * if f_args.argc == 0: # <<<<<<<<<<<<<< * f_args.argv = NULL * return */ __pyx_t_5 = ((__pyx_v_f_args->argc == 0) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":159 * f_args.argc = len(args) * if f_args.argc == 0: * f_args.argv = NULL # <<<<<<<<<<<<<< * return * */ __pyx_v_f_args->argv = NULL; /* "src/llfuse/misc.pxi":160 * if f_args.argc == 0: * f_args.argv = NULL * return # <<<<<<<<<<<<<< * * f_args.allocated = 1 */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":162 * return * * f_args.allocated = 1 # <<<<<<<<<<<<<< * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) * */ __pyx_v_f_args->allocated = 1; /* "src/llfuse/misc.pxi":163 * * f_args.allocated = 1 * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) # <<<<<<<<<<<<<< * * if f_args.argv is NULL: */ __pyx_v_f_args->argv = ((char **)calloc(__pyx_v_f_args->argc, (sizeof(char *)))); /* "src/llfuse/misc.pxi":165 * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) * * if f_args.argv is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_5 = ((__pyx_v_f_args->argv == NULL) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":166 * * if f_args.argv is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_8 = PyErr_NoMemory(); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L7; } __pyx_L7:; /* "src/llfuse/misc.pxi":168 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) */ { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/misc.pxi":169 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) */ __pyx_t_12 = 0; __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_7); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L8_error;} #else __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L8_error;} #endif __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_7); __pyx_t_7 = 0; __pyx_v_i = __pyx_t_12; __pyx_t_12 = (__pyx_t_12 + 1); /* "src/llfuse/misc.pxi":170 * try: * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) # <<<<<<<<<<<<<< * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * */ __pyx_t_13 = PyBytes_AsStringAndSize(__pyx_v_el, (&__pyx_v_arg), ((Py_ssize_t *)(&__pyx_v_size))); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 170; __pyx_clineno = __LINE__; goto __pyx_L8_error;} /* "src/llfuse/misc.pxi":171 * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) # <<<<<<<<<<<<<< * * if f_args.argv[i] is NULL: */ (__pyx_v_f_args->argv[__pyx_v_i]) = ((char *)malloc(((__pyx_v_size + 1) * (sizeof(char))))); /* "src/llfuse/misc.pxi":173 * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * * if f_args.argv[i] is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_5 = (((__pyx_v_f_args->argv[__pyx_v_i]) == NULL) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":174 * * if f_args.argv[i] is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * string.strncpy(f_args.argv[i], arg, size+1) */ __pyx_t_8 = PyErr_NoMemory(); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 174; __pyx_clineno = __LINE__; goto __pyx_L8_error;} goto __pyx_L18; } __pyx_L18:; /* "src/llfuse/misc.pxi":176 * cpython.exc.PyErr_NoMemory() * * string.strncpy(f_args.argv[i], arg, size+1) # <<<<<<<<<<<<<< * except: * for i in range(f_args.argc): */ strncpy((__pyx_v_f_args->argv[__pyx_v_i]), __pyx_v_arg, (__pyx_v_size + 1)); /* "src/llfuse/misc.pxi":169 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L15_try_end; __pyx_L8_error:; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":177 * * string.strncpy(f_args.argv[i], arg, size+1) * except: # <<<<<<<<<<<<<< * for i in range(f_args.argc): * # Freeing a NULL pointer (if this element has not been allocated */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 177; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_3); /* "src/llfuse/misc.pxi":178 * string.strncpy(f_args.argv[i], arg, size+1) * except: * for i in range(f_args.argc): # <<<<<<<<<<<<<< * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. */ __pyx_t_12 = __pyx_v_f_args->argc; for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_i = __pyx_t_13; /* "src/llfuse/misc.pxi":181 * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. * stdlib.free(f_args.argv[i]) # <<<<<<<<<<<<<< * stdlib.free(f_args.argv) * raise */ free((__pyx_v_f_args->argv[__pyx_v_i])); } /* "src/llfuse/misc.pxi":182 * # yet) is fine. * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) # <<<<<<<<<<<<<< * raise * */ free(__pyx_v_f_args->argv); /* "src/llfuse/misc.pxi":183 * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) * raise # <<<<<<<<<<<<<< * * cdef class Lock: */ __Pyx_GIVEREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ErrRestore(__pyx_t_1, __pyx_t_7, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 183; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;} } __pyx_L10_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L1_error; __pyx_L15_try_end:; } /* "src/llfuse/misc.pxi":144 * fuse_ops.create = fuse_create * * cdef make_fuse_args(list args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_args_new); __Pyx_XDECREF(__pyx_v_el); __Pyx_XDECREF(__pyx_v_args); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":191 * ''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* Python wrapper */ static int __pyx_pw_6llfuse_4capi_4Lock_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6llfuse_4capi_4Lock_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock___init__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6llfuse_4capi_4Lock___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/llfuse/misc.pxi":192 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":191 * ''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.Lock.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":195 * 'provided instance instead.') * * def acquire(self, timeout=None): # <<<<<<<<<<<<<< * '''Acquire global lock * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_3acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_2acquire[] = "Lock.acquire(self, timeout=None)\nAcquire global lock\n\n If *timeout* is not None, and the lock could not be acquired\n after waiting for *timeout* seconds, return False. Otherwise\n return True.\n "; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_3acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_timeout = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("acquire (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "acquire") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 195; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_timeout = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("acquire", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 195; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_2acquire(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_timeout); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_2acquire(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_timeout) { int __pyx_v_ret; int __pyx_v_timeout_c; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("acquire", 0); /* "src/llfuse/misc.pxi":206 * cdef int timeout_c * * if timeout is None: # <<<<<<<<<<<<<< * timeout_c = 0 * else: */ __pyx_t_1 = (__pyx_v_timeout == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":207 * * if timeout is None: * timeout_c = 0 # <<<<<<<<<<<<<< * else: * timeout_c = timeout */ __pyx_v_timeout_c = 0; goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":209 * timeout_c = 0 * else: * timeout_c = timeout # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_timeout); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 209; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_timeout_c = __pyx_t_3; } __pyx_L3:; /* "src/llfuse/misc.pxi":211 * timeout_c = timeout * * with nogil: # <<<<<<<<<<<<<< * ret = acquire(timeout_c) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":212 * * with nogil: * ret = acquire(timeout_c) # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = acquire(__pyx_v_timeout_c); } /* "src/llfuse/misc.pxi":211 * timeout_c = timeout * * with nogil: # <<<<<<<<<<<<<< * ret = acquire(timeout_c) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "src/llfuse/misc.pxi":214 * ret = acquire(timeout_c) * * if ret == 0: # <<<<<<<<<<<<<< * return True * elif ret == ETIMEDOUT and timeout != 0: */ __pyx_t_2 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":215 * * if ret == 0: * return True # <<<<<<<<<<<<<< * elif ret == ETIMEDOUT and timeout != 0: * return False */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; } /* "src/llfuse/misc.pxi":216 * if ret == 0: * return True * elif ret == ETIMEDOUT and timeout != 0: # <<<<<<<<<<<<<< * return False * elif ret == EDEADLK: */ __pyx_t_1 = ((__pyx_v_ret == ETIMEDOUT) != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L8_bool_binop_done; } __pyx_t_4 = PyObject_RichCompare(__pyx_v_timeout, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 216; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 216; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __pyx_t_1; __pyx_L8_bool_binop_done:; if (__pyx_t_2) { /* "src/llfuse/misc.pxi":217 * return True * elif ret == ETIMEDOUT and timeout != 0: * return False # <<<<<<<<<<<<<< * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; } /* "src/llfuse/misc.pxi":218 * elif ret == ETIMEDOUT and timeout != 0: * return False * elif ret == EDEADLK: # <<<<<<<<<<<<<< * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: */ __pyx_t_2 = ((__pyx_v_ret == EDEADLK) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":219 * return False * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":220 * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: # <<<<<<<<<<<<<< * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: */ __pyx_t_2 = ((__pyx_v_ret == EPROTO) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":221 * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":222 * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_2 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":223 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":225 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def release(self): */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (!__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":195 * 'provided instance instead.') * * def acquire(self, timeout=None): # <<<<<<<<<<<<<< * '''Acquire global lock * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.Lock.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":227 * raise RuntimeError(strerror(ret)) * * def release(self): # <<<<<<<<<<<<<< * '''Release global lock''' * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_5release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_4release[] = "Lock.release(self)\nRelease global lock"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_5release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("release (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_4release(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_4release(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { int __pyx_v_ret; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("release", 0); /* "src/llfuse/misc.pxi":231 * * cdef int ret * with nogil: # <<<<<<<<<<<<<< * ret = release() * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":232 * cdef int ret * with nogil: * ret = release() # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = release(); } /* "src/llfuse/misc.pxi":231 * * cdef int ret * with nogil: # <<<<<<<<<<<<<< * ret = release() * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "src/llfuse/misc.pxi":234 * ret = release() * * if ret == 0: # <<<<<<<<<<<<<< * return * elif ret == EPERM: */ __pyx_t_1 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":235 * * if ret == 0: * return # <<<<<<<<<<<<<< * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":236 * if ret == 0: * return * elif ret == EPERM: # <<<<<<<<<<<<<< * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: */ __pyx_t_1 = ((__pyx_v_ret == EPERM) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":237 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":238 * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_1 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":239 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":241 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def yield_(self, count=1): */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_5) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":227 * raise RuntimeError(strerror(ret)) * * def release(self): # <<<<<<<<<<<<<< * '''Release global lock''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.Lock.release", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":243 * raise RuntimeError(strerror(ret)) * * def yield_(self, count=1): # <<<<<<<<<<<<<< * '''Yield global lock to a different thread * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_7yield_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_6yield_[] = "Lock.yield_(self, count=1)\nYield global lock to a different thread\n\n The *count* argument may be used to yield the lock up to\n *count* times if there are still other threads waiting for the\n lock.\n "; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_7yield_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_count = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("yield_ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_count,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)__pyx_int_1); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_count); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "yield_") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_count = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("yield_", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.yield_", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_6yield_(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_count); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_6yield_(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_count) { int __pyx_v_ret; int __pyx_v_count_c; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("yield_", 0); /* "src/llfuse/misc.pxi":254 * cdef int count_c * * count_c = count # <<<<<<<<<<<<<< * with nogil: * ret = c_yield(count_c) */ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_count); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 254; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_count_c = __pyx_t_1; /* "src/llfuse/misc.pxi":255 * * count_c = count * with nogil: # <<<<<<<<<<<<<< * ret = c_yield(count_c) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":256 * count_c = count * with nogil: * ret = c_yield(count_c) # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = c_yield(__pyx_v_count_c); } /* "src/llfuse/misc.pxi":255 * * count_c = count * with nogil: # <<<<<<<<<<<<<< * ret = c_yield(count_c) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "src/llfuse/misc.pxi":258 * ret = c_yield(count_c) * * if ret == 0: # <<<<<<<<<<<<<< * return * elif ret == EPERM: */ __pyx_t_2 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":259 * * if ret == 0: * return # <<<<<<<<<<<<<< * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":260 * if ret == 0: * return * elif ret == EPERM: # <<<<<<<<<<<<<< * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: */ __pyx_t_2 = ((__pyx_v_ret == EPERM) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":261 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":262 * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: # <<<<<<<<<<<<<< * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: */ __pyx_t_2 = ((__pyx_v_ret == EPROTO) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":263 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":264 * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: # <<<<<<<<<<<<<< * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: */ __pyx_t_2 = ((__pyx_v_ret == ENOMSG) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":265 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":266 * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_2 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":267 * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":269 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def __enter__(self): */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (!__pyx_t_6) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":243 * raise RuntimeError(strerror(ret)) * * def yield_(self, count=1): # <<<<<<<<<<<<<< * '''Yield global lock to a different thread * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.Lock.yield_", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":271 * raise RuntimeError(strerror(ret)) * * def __enter__(self): # <<<<<<<<<<<<<< * self.acquire() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_8__enter__[] = "Lock.__enter__(self)"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_8__enter__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_8__enter__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__enter__", 0); /* "src/llfuse/misc.pxi":272 * * def __enter__(self): * self.acquire() # <<<<<<<<<<<<<< * * def __exit__(self, exc_type, exc_val, exc_tb): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_acquire); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":271 * raise RuntimeError(strerror(ret)) * * def __enter__(self): # <<<<<<<<<<<<<< * self.acquire() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.Lock.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":274 * self.acquire() * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.release() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_10__exit__[] = "Lock.__exit__(self, exc_type, exc_val, exc_tb)"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_exc_type = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_val = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_tb = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_exc_type,&__pyx_n_s_exc_val,&__pyx_n_s_exc_tb,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_val)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_tb)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__exit__") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_exc_type = values[0]; __pyx_v_exc_val = values[1]; __pyx_v_exc_tb = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_10__exit__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_exc_type, __pyx_v_exc_val, __pyx_v_exc_tb); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_10__exit__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 0); /* "src/llfuse/misc.pxi":275 * * def __exit__(self, exc_type, exc_val, exc_tb): * self.release() # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_release); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":274 * self.acquire() * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.release() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.Lock.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":281 * '''Context manager to execute code while the global lock is released''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* Python wrapper */ static int __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager___init__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6llfuse_4capi_13NoLockManager___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/llfuse/misc.pxi":282 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":281 * '''Context manager to execute code while the global lock is released''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":285 * 'provided instance instead.') * * def __enter__ (self): # <<<<<<<<<<<<<< * lock.release() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_13NoLockManager_2__enter__[] = "NoLockManager.__enter__(self)"; static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__enter__", 0); /* "src/llfuse/misc.pxi":286 * * def __enter__ (self): * lock.release() # <<<<<<<<<<<<<< * * def __exit__(self, *a): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_release); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":285 * 'provided instance instead.') * * def __enter__ (self): # <<<<<<<<<<<<<< * lock.release() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":288 * lock.release() * * def __exit__(self, *a): # <<<<<<<<<<<<<< * lock.acquire() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_13NoLockManager_4__exit__[] = "NoLockManager.__exit__(self, *a)"; static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_a = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__exit__", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_a = __pyx_args; __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self), __pyx_v_a); /* function exit code */ __Pyx_XDECREF(__pyx_v_a); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 0); /* "src/llfuse/misc.pxi":289 * * def __exit__(self, *a): * lock.acquire() # <<<<<<<<<<<<<< * * def _notify_loop(): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_acquire); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":288 * lock.release() * * def __exit__(self, *a): # <<<<<<<<<<<<<< * lock.acquire() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_1_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi__notify_loop[] = "_notify_loop()\nRead notifications from queue and send to FUSE kernel module"; static PyMethodDef __pyx_mdef_6llfuse_4capi_1_notify_loop = {"_notify_loop", (PyCFunction)__pyx_pw_6llfuse_4capi_1_notify_loop, METH_NOARGS, __pyx_doc_6llfuse_4capi__notify_loop}; static PyObject *__pyx_pw_6llfuse_4capi_1_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_notify_loop (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi__notify_loop(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi__notify_loop(CYTHON_UNUSED PyObject *__pyx_self) { Py_ssize_t __pyx_v_len_; fuse_ino_t __pyx_v_ino; char *__pyx_v_cname; PyObject *__pyx_v_req = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; fuse_ino_t __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_notify_loop", 0); /* "src/llfuse/misc.pxi":298 * cdef char *cname * * while True: # <<<<<<<<<<<<<< * req = _notify_queue.get() * if req is None: */ while (1) { /* "src/llfuse/misc.pxi":299 * * while True: * req = _notify_queue.get() # <<<<<<<<<<<<<< * if req is None: * return */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_req, __pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":300 * while True: * req = _notify_queue.get() * if req is None: # <<<<<<<<<<<<<< * return * */ __pyx_t_4 = (__pyx_v_req == Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":301 * req = _notify_queue.get() * if req is None: * return # <<<<<<<<<<<<<< * * if isinstance(req, inval_inode_req): */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":303 * return * * if isinstance(req, inval_inode_req): # <<<<<<<<<<<<<< * ino = req.inode * if req.attr_only: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_inode_req); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = PyObject_IsInstance(__pyx_v_req, __pyx_t_1); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = (__pyx_t_5 != 0); if (__pyx_t_4) { /* "src/llfuse/misc.pxi":304 * * if isinstance(req, inval_inode_req): * ino = req.inode # <<<<<<<<<<<<<< * if req.attr_only: * with nogil: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_inode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ino = __pyx_t_6; /* "src/llfuse/misc.pxi":305 * if isinstance(req, inval_inode_req): * ino = req.inode * if req.attr_only: # <<<<<<<<<<<<<< * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_attr_only); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_4) { /* "src/llfuse/misc.pxi":306 * ino = req.inode * if req.attr_only: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":307 * if req.attr_only: * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) # <<<<<<<<<<<<<< * else: * with nogil: */ fuse_lowlevel_notify_inval_inode(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, -1, 0); } /* "src/llfuse/misc.pxi":306 * ino = req.inode * if req.attr_only: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L12; } __pyx_L12:; } } goto __pyx_L7; } /*else*/ { /* "src/llfuse/misc.pxi":309 * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":310 * else: * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) # <<<<<<<<<<<<<< * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) */ fuse_lowlevel_notify_inval_inode(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, 0, 0); } /* "src/llfuse/misc.pxi":309 * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L17; } __pyx_L17:; } } } __pyx_L7:; goto __pyx_L6; } /* "src/llfuse/misc.pxi":311 * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_entry_req); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 311; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyObject_IsInstance(__pyx_v_req, __pyx_t_1); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 311; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":312 * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) # <<<<<<<<<<<<<< * ino = req.inode_p * with nogil: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = PyBytes_AsStringAndSize(__pyx_t_1, (&__pyx_v_cname), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":313 * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p # <<<<<<<<<<<<<< * with nogil: * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_inode_p); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ino = __pyx_t_6; /* "src/llfuse/misc.pxi":314 * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":315 * ino = req.inode_p * with nogil: * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) # <<<<<<<<<<<<<< * else: * raise RuntimeError("Weird request received: %r", req) */ fuse_lowlevel_notify_inval_entry(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, __pyx_v_cname, __pyx_v_len_); } /* "src/llfuse/misc.pxi":314 * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } goto __pyx_L6; } /*else*/ { /* "src/llfuse/misc.pxi":317 * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: * raise RuntimeError("Weird request received: %r", req) # <<<<<<<<<<<<<< * * cdef str2bytes(s): */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_u_Weird_request_received_r); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Weird_request_received_r); __Pyx_GIVEREF(__pyx_kp_u_Weird_request_received_r); __Pyx_INCREF(__pyx_v_req); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_req); __Pyx_GIVEREF(__pyx_v_req); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_L6:; } /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi._notify_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_req); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":319 * raise RuntimeError("Weird request received: %r", req) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes * */ static PyObject *__pyx_f_6llfuse_4capi_str2bytes(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("str2bytes", 0); /* "src/llfuse/misc.pxi":326 * ''' * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return s * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":327 * * if PY_MAJOR_VERSION < 3: * return s # <<<<<<<<<<<<<< * else: * return s.encode(fse, 'surrogateescape') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":329 * return s * else: * return s.encode(fse, 'surrogateescape') # <<<<<<<<<<<<<< * * cdef bytes2str(s): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_fse); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "src/llfuse/misc.pxi":319 * raise RuntimeError("Weird request received: %r", req) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":331 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str * */ static PyObject *__pyx_f_6llfuse_4capi_bytes2str(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bytes2str", 0); /* "src/llfuse/misc.pxi":338 * ''' * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return s * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":339 * * if PY_MAJOR_VERSION < 3: * return s # <<<<<<<<<<<<<< * else: * return s.decode(fse, 'surrogateescape') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":341 * return s * else: * return s.decode(fse, 'surrogateescape') # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_decode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_fse); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "src/llfuse/misc.pxi":331 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_3listdir(PyObject *__pyx_self, PyObject *__pyx_v_path); /*proto*/ static char __pyx_doc_6llfuse_4capi_2listdir[] = "listdir(path)\nLike `os.listdir`, but releases the GIL.\n\n This function returns an iterator over the directory entries in\n *path*. The returned values are of type :ref:`str\n ` in both Python 2.x and 3.x.\n\n In Python 2.x :class:`str` is equivalent to `bytes` so all names\n can be represented. In Python 3.x, surrogate escape coding (cf.\n `PEP 383 `_) is used for\n directory names that do not have a string representation.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_3listdir = {"listdir", (PyCFunction)__pyx_pw_6llfuse_4capi_3listdir, METH_O, __pyx_doc_6llfuse_4capi_2listdir}; static PyObject *__pyx_pw_6llfuse_4capi_3listdir(PyObject *__pyx_self, PyObject *__pyx_v_path) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("listdir (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_2listdir(__pyx_self, ((PyObject *)__pyx_v_path)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_2listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path) { DIR *__pyx_v_dirp; struct dirent __pyx_v_ent; struct dirent *__pyx_v_res; int __pyx_v_ret; char *__pyx_v_buf; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_names = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("listdir", 0); /* "src/llfuse/fuse_api.pxi":27 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":28 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef dirent.DIR* dirp */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":36 * cdef char* buf * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * buf = path_b * */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":37 * * path_b = str2bytes(path) * buf = path_b # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_buf = ((char *)__pyx_t_4); /* "src/llfuse/fuse_api.pxi":39 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = dirent.opendir(buf) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":40 * * with nogil: * dirp = dirent.opendir(buf) # <<<<<<<<<<<<<< * * if dirp == NULL: */ __pyx_v_dirp = opendir(__pyx_v_buf); } /* "src/llfuse/fuse_api.pxi":39 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = dirent.opendir(buf) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "src/llfuse/fuse_api.pxi":42 * dirp = dirent.opendir(buf) * * if dirp == NULL: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_dirp == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":43 * * if dirp == NULL: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * names = list() */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":45 * raise OSError(errno.errno, strerror(errno.errno), path) * * names = list() # <<<<<<<<<<<<<< * while True: * errno.errno = 0 */ __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_v_names = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; /* "src/llfuse/fuse_api.pxi":46 * * names = list() * while True: # <<<<<<<<<<<<<< * errno.errno = 0 * with nogil: */ while (1) { /* "src/llfuse/fuse_api.pxi":47 * names = list() * while True: * errno.errno = 0 # <<<<<<<<<<<<<< * with nogil: * ret = dirent.readdir_r(dirp, &ent, &res) */ errno = 0; /* "src/llfuse/fuse_api.pxi":48 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * ret = dirent.readdir_r(dirp, &ent, &res) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":49 * errno.errno = 0 * with nogil: * ret = dirent.readdir_r(dirp, &ent, &res) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = readdir_r(__pyx_v_dirp, (&__pyx_v_ent), (&__pyx_v_res)); } /* "src/llfuse/fuse_api.pxi":48 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * ret = dirent.readdir_r(dirp, &ent, &res) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L14; } __pyx_L14:; } } /* "src/llfuse/fuse_api.pxi":51 * ret = dirent.readdir_r(dirp, &ent, &res) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: */ __pyx_t_3 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":52 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * if res is NULL: * break */ __pyx_t_5 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":53 * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: # <<<<<<<<<<<<<< * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: */ __pyx_t_3 = ((__pyx_v_res == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":54 * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: * break # <<<<<<<<<<<<<< * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: * continue */ goto __pyx_L9_break; } /* "src/llfuse/fuse_api.pxi":55 * if res is NULL: * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: # <<<<<<<<<<<<<< * continue * */ __pyx_t_2 = ((strcmp(__pyx_v_ent.d_name, __pyx_k__49) == 0) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L18_bool_binop_done; } __pyx_t_2 = ((strcmp(__pyx_v_ent.d_name, __pyx_k__50) == 0) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L18_bool_binop_done:; if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":56 * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: * continue # <<<<<<<<<<<<<< * * names.append(bytes2str(PyBytes_FromString(ent.d_name))) */ goto __pyx_L8_continue; } /* "src/llfuse/fuse_api.pxi":58 * continue * * names.append(bytes2str(PyBytes_FromString(ent.d_name))) # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyBytes_FromString(__pyx_v_ent.d_name); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __pyx_f_6llfuse_4capi_bytes2str(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_names, __pyx_t_1); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_L8_continue:; } __pyx_L9_break:; /* "src/llfuse/fuse_api.pxi":60 * names.append(bytes2str(PyBytes_FromString(ent.d_name))) * * with nogil: # <<<<<<<<<<<<<< * dirent.closedir(dirp) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":61 * * with nogil: * dirent.closedir(dirp) # <<<<<<<<<<<<<< * * return names */ closedir(__pyx_v_dirp); } /* "src/llfuse/fuse_api.pxi":60 * names.append(bytes2str(PyBytes_FromString(ent.d_name))) * * with nogil: # <<<<<<<<<<<<<< * dirent.closedir(dirp) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } /* "src/llfuse/fuse_api.pxi":63 * dirent.closedir(dirp) * * return names # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_names); __pyx_r = __pyx_v_names; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("llfuse.capi.listdir", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_names); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_5setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4setxattr[] = "setxattr(path, name, bytes value, namespace=u'user')\nSet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. *value* has to be of type `bytes`.\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast the `os.setxattr` function from the standard library,\n the method provided by Python-LLFUSE is also available for non-Linux\n systems.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_5setxattr = {"setxattr", (PyCFunction)__pyx_pw_6llfuse_4capi_5setxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4setxattr}; static PyObject *__pyx_pw_6llfuse_4capi_5setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_value = 0; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_value,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 2); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setxattr") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; __pyx_v_value = ((PyObject*)values[2]); __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 1, "value", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_4setxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_value, __pyx_v_namespace); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cvalue; char *__pyx_v_cpath; char *__pyx_v_cname; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; char *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setxattr", 0); /* "src/llfuse/fuse_api.pxi":81 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":82 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":84 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str_t): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_name, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { /* "src/llfuse/fuse_api.pxi":85 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":87 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_1 = __pyx_v_namespace; __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":89 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef int ret */ __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 89; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); /* "src/llfuse/fuse_api.pxi":88 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":104 * cnamespace = xattr.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":105 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_name_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":106 * path_b = str2bytes(path) * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_5 = PyBytes_AsStringAndSize(__pyx_v_value, (&__pyx_v_cvalue), (&__pyx_v_len_)); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 106; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":107 * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cpath = ((char *)__pyx_t_6); /* "src/llfuse/fuse_api.pxi":108 * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_name_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cname = ((char *)__pyx_t_6); /* "src/llfuse/fuse_api.pxi":111 * * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_set_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":116 * cvalue, len_) * ELSE: * ret = xattr.setxattr(cpath, cname, cvalue, len_, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_4libc_5xattr_setxattr(__pyx_v_cpath, __pyx_v_cname, __pyx_v_cvalue, __pyx_v_len_, 0); } /* "src/llfuse/fuse_api.pxi":111 * * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_set_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L10; } __pyx_L10:; } } /* "src/llfuse/fuse_api.pxi":118 * ret = xattr.setxattr(cpath, cname, cvalue, len_, 0) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":119 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_9) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("llfuse.capi.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_7getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_6getxattr[] = "getxattr(path, name, int size_guess=128, namespace=u'user')\nGet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. Returns a value of type `bytes`.\n\n If the caller knows the approximate size of the attribute value,\n it should be supplied in *size_guess*. If the guess turns out\n to be wrong, the system call has to be carried out three times\n (the first call will fail, the second determines the size and\n the third finally gets the value).\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast the `os.setxattr` function from the standard library,\n the method provided by Python-LLFUSE is also available for non-Linux\n systems.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_7getxattr = {"getxattr", (PyCFunction)__pyx_pw_6llfuse_4capi_7getxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_6getxattr}; static PyObject *__pyx_pw_6llfuse_4capi_7getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; int __pyx_v_size_guess; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_size_guess,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_size_guess); if (value) { values[2] = value; kw_args--; } } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getxattr") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; if (values[2]) { __pyx_v_size_guess = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_size_guess == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } else { __pyx_v_size_guess = ((int)128); } __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_6getxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_size_guess, __pyx_v_namespace); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_6getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, int __pyx_v_size_guess, PyObject *__pyx_v_namespace) { Py_ssize_t __pyx_v_ret; char *__pyx_v_buf; char *__pyx_v_cpath; char *__pyx_v_cname; size_t __pyx_v_bufsize; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; char *__pyx_t_5; PyObject *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("getxattr", 0); /* "src/llfuse/fuse_api.pxi":143 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":144 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":146 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str_t): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_name, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { /* "src/llfuse/fuse_api.pxi":147 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":149 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_1 = __pyx_v_namespace; __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":151 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef ssize_t ret */ __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); /* "src/llfuse/fuse_api.pxi":150 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":166 * cnamespace = xattr.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * cpath = path_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":167 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 167; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_name_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":168 * path_b = str2bytes(path) * name_b = str2bytes(name) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cpath = ((char *)__pyx_t_5); /* "src/llfuse/fuse_api.pxi":169 * name_b = str2bytes(name) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * bufsize = size_guess */ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_name_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cname = ((char *)__pyx_t_5); /* "src/llfuse/fuse_api.pxi":171 * cname = name_b * * bufsize = size_guess # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * */ __pyx_v_bufsize = __pyx_v_size_guess; /* "src/llfuse/fuse_api.pxi":172 * * bufsize = size_guess * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * * if buf is NULL: */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "src/llfuse/fuse_api.pxi":174 * buf = stdlib.malloc(bufsize * sizeof(char)) * * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_3 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":175 * * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L8; } __pyx_L8:; /* "src/llfuse/fuse_api.pxi":177 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * with nogil: * IF TARGET_PLATFORM == 'freebsd': */ /*try:*/ { /* "src/llfuse/fuse_api.pxi":178 * * try: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":186 * errno.errno = errno.ERANGE * ELSE: * ret = xattr.getxattr(cpath, cname, buf, bufsize) # <<<<<<<<<<<<<< * * if ret < 0 and errno.errno == errno.ERANGE: */ __pyx_v_ret = __pyx_f_4libc_5xattr_getxattr(__pyx_v_cpath, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize); } /* "src/llfuse/fuse_api.pxi":178 * * try: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L14; } __pyx_L14:; } } /* "src/llfuse/fuse_api.pxi":188 * ret = xattr.getxattr(cpath, cname, buf, bufsize) * * if ret < 0 and errno.errno == errno.ERANGE: # <<<<<<<<<<<<<< * with nogil: * IF TARGET_PLATFORM == 'freebsd': */ __pyx_t_2 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_2 = ((errno == ERANGE) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":189 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":194 * NULL, 0) * ELSE: * ret = xattr.getxattr(cpath, cname, NULL, 0) # <<<<<<<<<<<<<< * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) */ __pyx_v_ret = __pyx_f_4libc_5xattr_getxattr(__pyx_v_cpath, __pyx_v_cname, NULL, 0); } /* "src/llfuse/fuse_api.pxi":189 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L20; } __pyx_L20:; } } /* "src/llfuse/fuse_api.pxi":195 * ELSE: * ret = xattr.getxattr(cpath, cname, NULL, 0) * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret */ __pyx_t_3 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":196 * ret = xattr.getxattr(cpath, cname, NULL, 0) * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * bufsize = ret * stdlib.free(buf) */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_9) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} } /* "src/llfuse/fuse_api.pxi":197 * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret # <<<<<<<<<<<<<< * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) */ __pyx_v_bufsize = ((size_t)__pyx_v_ret); /* "src/llfuse/fuse_api.pxi":198 * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret * stdlib.free(buf) # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: */ free(__pyx_v_buf); /* "src/llfuse/fuse_api.pxi":199 * bufsize = ret * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * if buf is NULL: * cpython.exc.PyErr_NoMemory() */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "src/llfuse/fuse_api.pxi":200 * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_3 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":201 * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 201; __pyx_clineno = __LINE__; goto __pyx_L10_error;} goto __pyx_L22; } __pyx_L22:; /* "src/llfuse/fuse_api.pxi":203 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":208 * buf, bufsize) * ELSE: * ret = xattr.getxattr(cpath, cname, buf, bufsize) # <<<<<<<<<<<<<< * * if ret < 0: */ __pyx_v_ret = __pyx_f_4libc_5xattr_getxattr(__pyx_v_cpath, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize); } /* "src/llfuse/fuse_api.pxi":203 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L25; } __pyx_L25:; } } goto __pyx_L15; } __pyx_L15:; /* "src/llfuse/fuse_api.pxi":210 * ret = xattr.getxattr(cpath, cname, buf, bufsize) * * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":211 * * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * return PyBytes_FromStringAndSize(buf, ret) */ __pyx_t_4 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_8) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_4 = 0; __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} } /* "src/llfuse/fuse_api.pxi":213 * raise OSError(errno.errno, strerror(errno.errno), path) * * return PyBytes_FromStringAndSize(buf, ret) # <<<<<<<<<<<<<< * * finally: */ __Pyx_XDECREF(__pyx_r); __pyx_t_7 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_ret); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 213; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L9_return; } /* "src/llfuse/fuse_api.pxi":216 * * finally: * stdlib.free(buf) # <<<<<<<<<<<<<< * * def init(ops, mountpoint, list args): */ /*finally:*/ { /*exception exit:*/{ __pyx_L10_error:; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_11 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { free(__pyx_v_buf); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L1_error; } __pyx_L9_return: { __pyx_t_19 = __pyx_r; __pyx_r = 0; free(__pyx_v_buf); __pyx_r = __pyx_t_19; __pyx_t_19 = 0; goto __pyx_L0; } } /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("llfuse.capi.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_9init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_8init[] = "init(ops, mountpoint, list args)\nInitialize and mount FUSE file system\n\n *ops* has to be an instance of the `Operations` class (or another\n class defining the same methods).\n\n *args* has to be a list of strings. Valid options are listed under ``struct\n fuse_opt fuse_mount_opts[]``\n (`mount.c:82 `_)\n and ``struct fuse_opt fuse_ll_opts[]``\n (`fuse_lowlevel_c:2209 `_).\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_9init = {"init", (PyCFunction)__pyx_pw_6llfuse_4capi_9init, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_8init}; static PyObject *__pyx_pw_6llfuse_4capi_9init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_ops = 0; PyObject *__pyx_v_mountpoint = 0; PyObject *__pyx_v_args = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ops,&__pyx_n_s_mountpoint,&__pyx_n_s_args,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ops)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mountpoint)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, 2); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "init") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_ops = values[0]; __pyx_v_mountpoint = values[1]; __pyx_v_args = ((PyObject*)values[2]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyList_Type), 1, "args", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_8init(__pyx_self, __pyx_v_ops, __pyx_v_mountpoint, __pyx_v_args); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_8init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_args) { struct fuse_args __pyx_v_f_args; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; char *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("init", 0); /* "src/llfuse/fuse_api.pxi":231 * ''' * * log.debug('Initializing llfuse') # <<<<<<<<<<<<<< * cdef fuse_args f_args * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":234 * cdef fuse_args f_args * * if not isinstance(mountpoint, str_t): # <<<<<<<<<<<<<< * raise TypeError('*mountpoint_* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_mountpoint, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":235 * * if not isinstance(mountpoint, str_t): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":243 * global channel * * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) # <<<<<<<<<<<<<< * operations = ops * */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_path); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_abspath); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_5) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_mountpoint); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; __Pyx_INCREF(__pyx_v_mountpoint); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_mountpoint); __Pyx_GIVEREF(__pyx_v_mountpoint); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_mountpoint_b, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":244 * * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) * operations = ops # <<<<<<<<<<<<<< * * # Initialize Python thread support */ __Pyx_INCREF(__pyx_v_ops); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_operations); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_operations, __pyx_v_ops); __Pyx_GIVEREF(__pyx_v_ops); /* "src/llfuse/fuse_api.pxi":247 * * # Initialize Python thread support * PyEval_InitThreads() # <<<<<<<<<<<<<< * * make_fuse_args(args, &f_args) */ PyEval_InitThreads(); /* "src/llfuse/fuse_api.pxi":249 * PyEval_InitThreads() * * make_fuse_args(args, &f_args) # <<<<<<<<<<<<<< * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) */ __pyx_t_2 = __pyx_f_6llfuse_4capi_make_fuse_args(__pyx_v_args, (&__pyx_v_f_args)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 249; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":250 * * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') # <<<<<<<<<<<<<< * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":251 * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) # <<<<<<<<<<<<<< * if not channel: * raise RuntimeError('fuse_mount failed') */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 251; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_6llfuse_4capi_channel = fuse_mount(((char *)__pyx_t_7), (&__pyx_v_f_args)); /* "src/llfuse/fuse_api.pxi":252 * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: # <<<<<<<<<<<<<< * raise RuntimeError('fuse_mount failed') * */ __pyx_t_4 = ((!(__pyx_v_6llfuse_4capi_channel != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":253 * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: * raise RuntimeError('fuse_mount failed') # <<<<<<<<<<<<<< * * log.debug('Calling fuse_lowlevel_new') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":255 * raise RuntimeError('fuse_mount failed') * * log.debug('Calling fuse_lowlevel_new') # <<<<<<<<<<<<<< * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":256 * * log.debug('Calling fuse_lowlevel_new') * init_fuse_ops() # <<<<<<<<<<<<<< * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: */ __pyx_f_6llfuse_4capi_init_fuse_ops(); /* "src/llfuse/fuse_api.pxi":257 * log.debug('Calling fuse_lowlevel_new') * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) # <<<<<<<<<<<<<< * if not session: * fuse_unmount(mountpoint_b, channel) */ __pyx_v_6llfuse_4capi_session = fuse_lowlevel_new((&__pyx_v_f_args), (&__pyx_v_6llfuse_4capi_fuse_ops), (sizeof(__pyx_v_6llfuse_4capi_fuse_ops)), NULL); /* "src/llfuse/fuse_api.pxi":258 * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") */ __pyx_t_4 = ((!(__pyx_v_6llfuse_4capi_session != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":259 * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * raise RuntimeError("fuse_lowlevel_new() failed") * */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_7), __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":260 * if not session: * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_set_signal_handlers') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":262 * raise RuntimeError("fuse_lowlevel_new() failed") * * log.debug('Calling fuse_set_signal_handlers') # <<<<<<<<<<<<<< * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":263 * * log.debug('Calling fuse_set_signal_handlers') * if fuse_set_signal_handlers(session) == -1: # <<<<<<<<<<<<<< * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) */ __pyx_t_4 = ((fuse_set_signal_handlers(__pyx_v_6llfuse_4capi_session) == -1) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":264 * log.debug('Calling fuse_set_signal_handlers') * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") */ fuse_session_destroy(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":265 * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * raise RuntimeError("fuse_set_signal_handlers() failed") * */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_7), __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":266 * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_add_chan') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":268 * raise RuntimeError("fuse_set_signal_handlers() failed") * * log.debug('Calling fuse_session_add_chan') # <<<<<<<<<<<<<< * fuse_session_add_chan(session, channel) * */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":269 * * log.debug('Calling fuse_session_add_chan') * fuse_session_add_chan(session, channel) # <<<<<<<<<<<<<< * * def main(single=False): */ fuse_session_add_chan(__pyx_v_6llfuse_4capi_session, __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_11main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_10main[] = "main(single=False)\nRun FUSE main loop\n\n If *single* is True, all requests will be handled sequentially by\n the thread that has called `main`. If *single* is False, multiple\n worker threads will be started and work on requests concurrently.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_11main = {"main", (PyCFunction)__pyx_pw_6llfuse_4capi_11main, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_10main}; static PyObject *__pyx_pw_6llfuse_4capi_11main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_single = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("main (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_single,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_single); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "main") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_single = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("main", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_10main(__pyx_self, __pyx_v_single); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_10main(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_single) { int __pyx_v_ret; PyObject *__pyx_v_t = NULL; PyObject *__pyx_v_tmp = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("main", 0); /* "src/llfuse/fuse_api.pxi":282 * global exc_info * * if session == NULL: # <<<<<<<<<<<<<< * raise RuntimeError('Need to call init() before main()') * */ __pyx_t_1 = ((__pyx_v_6llfuse_4capi_session == NULL) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":283 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * # Start notification handling thread */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":286 * * # Start notification handling thread * t = threading.Thread(target=_notify_loop) # <<<<<<<<<<<<<< * t.daemon = True * t.start() */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_threading); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Thread); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_loop); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_target, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_t = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":287 * # Start notification handling thread * t = threading.Thread(target=_notify_loop) * t.daemon = True # <<<<<<<<<<<<<< * t.start() * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_daemon, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":288 * t = threading.Thread(target=_notify_loop) * t.daemon = True * t.start() # <<<<<<<<<<<<<< * * exc_info = None */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_start); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":290 * t.start() * * exc_info = None # <<<<<<<<<<<<<< * * if single: */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":292 * exc_info = None * * if single: # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_loop') * with nogil: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_single); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 292; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":293 * * if single: * log.debug('Calling fuse_session_loop') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop(session) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":294 * if single: * log.debug('Calling fuse_session_loop') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":295 * log.debug('Calling fuse_session_loop') * with nogil: * ret = fuse_session_loop(session) # <<<<<<<<<<<<<< * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: */ __pyx_v_ret = fuse_session_loop(__pyx_v_6llfuse_4capi_session); } /* "src/llfuse/fuse_api.pxi":294 * if single: * log.debug('Calling fuse_session_loop') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L7; } __pyx_L7:; } } /* "src/llfuse/fuse_api.pxi":296 * with nogil: * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop failed") */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_put); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_block, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_timeout, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__66, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/fuse_api.pxi":297 * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_loop failed") * else: */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":298 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop failed") # <<<<<<<<<<<<<< * else: * log.debug('Calling fuse_session_loop_mt') */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } goto __pyx_L4; } /*else*/ { /* "src/llfuse/fuse_api.pxi":300 * raise RuntimeError("fuse_session_loop failed") * else: * log.debug('Calling fuse_session_loop_mt') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop_mt(session) */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/fuse_api.pxi":301 * else: * log.debug('Calling fuse_session_loop_mt') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":302 * log.debug('Calling fuse_session_loop_mt') * with nogil: * ret = fuse_session_loop_mt(session) # <<<<<<<<<<<<<< * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: */ __pyx_v_ret = fuse_session_loop_mt(__pyx_v_6llfuse_4capi_session); } /* "src/llfuse/fuse_api.pxi":301 * else: * log.debug('Calling fuse_session_loop_mt') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L11; } __pyx_L11:; } } /* "src/llfuse/fuse_api.pxi":303 * with nogil: * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_put); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_block, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_timeout, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__69, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":304 * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_loop_mt() failed") * */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":305 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") # <<<<<<<<<<<<<< * * if exc_info: */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } __pyx_L4:; /* "src/llfuse/fuse_api.pxi":307 * raise RuntimeError("fuse_session_loop_mt() failed") * * if exc_info: # <<<<<<<<<<<<<< * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 307; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":309 * if exc_info: * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":310 * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') * tmp = exc_info # <<<<<<<<<<<<<< * exc_info = None * */ __Pyx_INCREF(__pyx_v_6llfuse_4capi_exc_info); __pyx_v_tmp = __pyx_v_6llfuse_4capi_exc_info; /* "src/llfuse/fuse_api.pxi":311 * log.debug('Terminated main loop because request handler raised exception, re-raising..') * tmp = exc_info * exc_info = None # <<<<<<<<<<<<<< * * # The explicit version check works around a Cython bug with */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":316 * # the 3-parameter version of the raise statement, c.f. * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise tmp[0], tmp[1], tmp[2] * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":317 * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: * raise tmp[0], tmp[1], tmp[2] # <<<<<<<<<<<<<< * else: * raise tmp[1].with_traceback(tmp[2]) */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_2, __pyx_t_3, __pyx_t_4, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/fuse_api.pxi":319 * raise tmp[0], tmp[1], tmp[2] * else: * raise tmp[1].with_traceback(tmp[2]) # <<<<<<<<<<<<<< * * def close(unmount=True): */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_with_traceback); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_5) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_t); __Pyx_XDECREF(__pyx_v_tmp); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_12close[] = "close(unmount=True)\nUnmount file system and clean up\n\n If *unmount* is False, only clean up operations are peformed, but\n the file system is not unmounted. As long as the file system\n process is still running, all requests will hang. Once the process\n has terminated, these (and all future) requests fail with ESHUTDOWN.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_13close = {"close", (PyCFunction)__pyx_pw_6llfuse_4capi_13close, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_12close}; static PyObject *__pyx_pw_6llfuse_4capi_13close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_unmount = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_unmount,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_True); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_unmount); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "close") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_unmount = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("close", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_12close(__pyx_self, __pyx_v_unmount); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_12close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount) { PyObject *__pyx_v_tmp = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close", 0); /* "src/llfuse/fuse_api.pxi":335 * global exc_info * * log.debug('Calling fuse_session_remove_chan') # <<<<<<<<<<<<<< * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":336 * * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) # <<<<<<<<<<<<<< * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) */ fuse_session_remove_chan(__pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":337 * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') # <<<<<<<<<<<<<< * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":338 * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_destroy') * fuse_session_destroy(session) */ fuse_remove_signal_handlers(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":339 * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') # <<<<<<<<<<<<<< * fuse_session_destroy(session) * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":340 * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') * fuse_session_destroy(session) # <<<<<<<<<<<<<< * * if unmount: */ fuse_session_destroy(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":342 * fuse_session_destroy(session) * * if unmount: # <<<<<<<<<<<<<< * log.debug('Calling fuse_unmount') * fuse_unmount(mountpoint_b, channel) */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_unmount); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":343 * * if unmount: * log.debug('Calling fuse_unmount') # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * else: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":344 * if unmount: * log.debug('Calling fuse_unmount') * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * else: * fuse_chan_destroy(channel) */ __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_4), __pyx_v_6llfuse_4capi_channel); goto __pyx_L3; } /*else*/ { /* "src/llfuse/fuse_api.pxi":346 * fuse_unmount(mountpoint_b, channel) * else: * fuse_chan_destroy(channel) # <<<<<<<<<<<<<< * * mountpoint_b = None */ fuse_chan_destroy(__pyx_v_6llfuse_4capi_channel); } __pyx_L3:; /* "src/llfuse/fuse_api.pxi":348 * fuse_chan_destroy(channel) * * mountpoint_b = None # <<<<<<<<<<<<<< * session = NULL * channel = NULL */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_mountpoint_b, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":349 * * mountpoint_b = None * session = NULL # <<<<<<<<<<<<<< * channel = NULL * */ __pyx_v_6llfuse_4capi_session = NULL; /* "src/llfuse/fuse_api.pxi":350 * mountpoint_b = None * session = NULL * channel = NULL # <<<<<<<<<<<<<< * * # destroy handler may have given us an exception */ __pyx_v_6llfuse_4capi_channel = NULL; /* "src/llfuse/fuse_api.pxi":353 * * # destroy handler may have given us an exception * if exc_info: # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":354 * # destroy handler may have given us an exception * if exc_info: * tmp = exc_info # <<<<<<<<<<<<<< * exc_info = None * */ __Pyx_INCREF(__pyx_v_6llfuse_4capi_exc_info); __pyx_v_tmp = __pyx_v_6llfuse_4capi_exc_info; /* "src/llfuse/fuse_api.pxi":355 * if exc_info: * tmp = exc_info * exc_info = None # <<<<<<<<<<<<<< * * # The explicit version check works around a Cython bug with */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":360 * # the 3-parameter version of the raise statement, c.f. * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise tmp[0], tmp[1], tmp[2] * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":361 * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: * raise tmp[0], tmp[1], tmp[2] # <<<<<<<<<<<<<< * else: * raise tmp[1].with_traceback(tmp[2]) */ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tmp, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_1, __pyx_t_2, __pyx_t_5, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/fuse_api.pxi":363 * raise tmp[0], tmp[1], tmp[2] * else: * raise tmp[1].with_traceback(tmp[2]) # <<<<<<<<<<<<<< * * def invalidate_inode(int inode, attr_only=False): */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_with_traceback); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_6) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_tmp); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_15invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_14invalidate_inode[] = "invalidate_inode(int inode, attr_only=False)\nInvalidate cache for *inode*\n\n Instructs the FUSE kernel module to forgot cached attributes and\n data (unless *attr_only* is True) for *inode*. This operation is\n carried out asynchronously, i.e. the method may return before the\n kernel has executed the request.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_15invalidate_inode = {"invalidate_inode", (PyCFunction)__pyx_pw_6llfuse_4capi_15invalidate_inode, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_14invalidate_inode}; static PyObject *__pyx_pw_6llfuse_4capi_15invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_inode; PyObject *__pyx_v_attr_only = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_inode (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode,&__pyx_n_s_attr_only,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inode)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_attr_only); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_inode") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_inode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_inode == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_attr_only = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_inode", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_14invalidate_inode(__pyx_self, __pyx_v_inode, __pyx_v_attr_only); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_14invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode, PyObject *__pyx_v_attr_only) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_inode", 0); /* "src/llfuse/fuse_api.pxi":374 * ''' * * _notify_queue.put(inval_inode_req(inode, attr_only)) # <<<<<<<<<<<<<< * * def invalidate_entry(int inode_p, bytes name): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_inode_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_inode); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_attr_only); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_attr_only); __Pyx_GIVEREF(__pyx_v_attr_only); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_17invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_16invalidate_entry[] = "invalidate_entry(int inode_p, bytes name)\nInvalidate directory entry\n\n Instructs the FUSE kernel module to forget about the directory\n entry *name* in the directory with inode *inode_p*. This operation\n is carried out asynchronously, i.e. the method may return before\n the kernel has executed the request.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_17invalidate_entry = {"invalidate_entry", (PyCFunction)__pyx_pw_6llfuse_4capi_17invalidate_entry, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_16invalidate_entry}; static PyObject *__pyx_pw_6llfuse_4capi_17invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_inode_p; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_entry (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode_p,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inode_p)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("invalidate_entry", 1, 2, 2, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_entry") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_inode_p = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_inode_p == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_name = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_entry", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_16invalidate_entry(__pyx_self, __pyx_v_inode_p, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_16invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode_p, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_entry", 0); /* "src/llfuse/fuse_api.pxi":385 * ''' * * _notify_queue.put(inval_entry_req(inode_p, name)) # <<<<<<<<<<<<<< * * def get_ino_t_bits(): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_entry_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_inode_p); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_19get_ino_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_18get_ino_t_bits[] = "get_ino_t_bits()\nReturn number of bits available for inode numbers\n\n Attempts to use inode values that need more bytes will result in\n `OverflowError`.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_19get_ino_t_bits = {"get_ino_t_bits", (PyCFunction)__pyx_pw_6llfuse_4capi_19get_ino_t_bits, METH_NOARGS, __pyx_doc_6llfuse_4capi_18get_ino_t_bits}; static PyObject *__pyx_pw_6llfuse_4capi_19get_ino_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_ino_t_bits (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_18get_ino_t_bits(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_18get_ino_t_bits(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations size_t __pyx_t_1; size_t __pyx_t_2; size_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_ino_t_bits", 0); /* "src/llfuse/fuse_api.pxi":393 * `OverflowError`. * ''' * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 # <<<<<<<<<<<<<< * * def get_off_t_bits(): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = (sizeof(fuse_ino_t)); __pyx_t_2 = (sizeof(ino_t)); if (((__pyx_t_1 < __pyx_t_2) != 0)) { __pyx_t_3 = __pyx_t_1; } else { __pyx_t_3 = __pyx_t_2; } __pyx_t_4 = __Pyx_PyInt_FromSize_t((__pyx_t_3 * 8)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 393; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("llfuse.capi.get_ino_t_bits", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_21get_off_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_20get_off_t_bits[] = "get_off_t_bits()\nReturn number of bytes available for file offsets\n\n Attempts to use values whose representation needs more bytes will\n result in `OverflowError`.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_21get_off_t_bits = {"get_off_t_bits", (PyCFunction)__pyx_pw_6llfuse_4capi_21get_off_t_bits, METH_NOARGS, __pyx_doc_6llfuse_4capi_20get_off_t_bits}; static PyObject *__pyx_pw_6llfuse_4capi_21get_off_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_off_t_bits (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_20get_off_t_bits(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_20get_off_t_bits(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_off_t_bits", 0); /* "src/llfuse/fuse_api.pxi":401 * result in `OverflowError`. * ''' * return sizeof(off_t) * 8 # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_FromSize_t(((sizeof(off_t)) * 8)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 401; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.get_off_t_bits", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "xattr.pxd":28 * int XATTR_NODEFAULT * * cdef inline int setxattr (char *path, char *name, # <<<<<<<<<<<<<< * void *value, int size, int flags) nogil: * return c_setxattr(path, name, value, size, flags, 0) */ static CYTHON_INLINE int __pyx_f_4libc_5xattr_setxattr(char *__pyx_v_path, char *__pyx_v_name, void *__pyx_v_value, int __pyx_v_size, int __pyx_v_flags) { int __pyx_r; /* "xattr.pxd":30 * cdef inline int setxattr (char *path, char *name, * void *value, int size, int flags) nogil: * return c_setxattr(path, name, value, size, flags, 0) # <<<<<<<<<<<<<< * * cdef inline int getxattr (char *path, char *name, */ __pyx_r = setxattr(__pyx_v_path, __pyx_v_name, __pyx_v_value, __pyx_v_size, __pyx_v_flags, 0); goto __pyx_L0; /* "xattr.pxd":28 * int XATTR_NODEFAULT * * cdef inline int setxattr (char *path, char *name, # <<<<<<<<<<<<<< * void *value, int size, int flags) nogil: * return c_setxattr(path, name, value, size, flags, 0) */ /* function exit code */ __pyx_L0:; return __pyx_r; } /* "xattr.pxd":32 * return c_setxattr(path, name, value, size, flags, 0) * * cdef inline int getxattr (char *path, char *name, # <<<<<<<<<<<<<< * void *value, int size) nogil: * return c_getxattr(path, name, value, size, 0, 0) */ static CYTHON_INLINE int __pyx_f_4libc_5xattr_getxattr(char *__pyx_v_path, char *__pyx_v_name, void *__pyx_v_value, int __pyx_v_size) { int __pyx_r; /* "xattr.pxd":34 * cdef inline int getxattr (char *path, char *name, * void *value, int size) nogil: * return c_getxattr(path, name, value, size, 0, 0) # <<<<<<<<<<<<<< * * ELIF TARGET_PLATFORM == 'freebsd': */ __pyx_r = getxattr(__pyx_v_path, __pyx_v_name, __pyx_v_value, __pyx_v_size, 0, 0); goto __pyx_L0; /* "xattr.pxd":32 * return c_setxattr(path, name, value, size, flags, 0) * * cdef inline int getxattr (char *path, char *name, # <<<<<<<<<<<<<< * void *value, int size) nogil: * return c_getxattr(path, name, value, size, 0, 0) */ /* function exit code */ __pyx_L0:; return __pyx_r; } static PyObject *__pyx_tp_new_6llfuse_4capi_Lock(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; return o; } static void __pyx_tp_dealloc_6llfuse_4capi_Lock(PyObject *o) { #if PY_VERSION_HEX >= 0x030400a1 if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif (*Py_TYPE(o)->tp_free)(o); } static PyMethodDef __pyx_methods_6llfuse_4capi_Lock[] = { {"acquire", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_3acquire, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_2acquire}, {"release", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_5release, METH_NOARGS, __pyx_doc_6llfuse_4capi_4Lock_4release}, {"yield_", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_7yield_, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_6yield_}, {"__enter__", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_9__enter__, METH_NOARGS, __pyx_doc_6llfuse_4capi_4Lock_8__enter__}, {"__exit__", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_11__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_10__exit__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6llfuse_4capi_Lock = { PyVarObject_HEAD_INIT(0, 0) "llfuse.capi.Lock", /*tp_name*/ sizeof(struct __pyx_obj_6llfuse_4capi_Lock), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6llfuse_4capi_Lock, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "Lock()\n\n This is the class of lock itself as well as a context manager to\n execute code while the global lock is being held.\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6llfuse_4capi_Lock, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_6llfuse_4capi_4Lock_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6llfuse_4capi_Lock, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyObject *__pyx_tp_new_6llfuse_4capi_NoLockManager(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; return o; } static void __pyx_tp_dealloc_6llfuse_4capi_NoLockManager(PyObject *o) { #if PY_VERSION_HEX >= 0x030400a1 if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif (*Py_TYPE(o)->tp_free)(o); } static PyMethodDef __pyx_methods_6llfuse_4capi_NoLockManager[] = { {"__enter__", (PyCFunction)__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__, METH_NOARGS, __pyx_doc_6llfuse_4capi_13NoLockManager_2__enter__}, {"__exit__", (PyCFunction)__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_13NoLockManager_4__exit__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6llfuse_4capi_NoLockManager = { PyVarObject_HEAD_INIT(0, 0) "llfuse.capi.NoLockManager", /*tp_name*/ sizeof(struct __pyx_obj_6llfuse_4capi_NoLockManager), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6llfuse_4capi_NoLockManager, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "NoLockManager()\nContext manager to execute code while the global lock is released", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6llfuse_4capi_NoLockManager, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6llfuse_4capi_NoLockManager, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { #if PY_VERSION_HEX < 0x03020000 { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, #else PyModuleDef_HEAD_INIT, #endif "capi", __pyx_k_capi_pxy_Copyright_2013_Nikolau, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_BaseException, __pyx_k_BaseException, sizeof(__pyx_k_BaseException), 0, 0, 1, 1}, {&__pyx_kp_u_Calling_fuse_lowlevel_new, __pyx_k_Calling_fuse_lowlevel_new, sizeof(__pyx_k_Calling_fuse_lowlevel_new), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_mount, __pyx_k_Calling_fuse_mount, sizeof(__pyx_k_Calling_fuse_mount), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_remove_signal_handl, __pyx_k_Calling_fuse_remove_signal_handl, sizeof(__pyx_k_Calling_fuse_remove_signal_handl), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_add_chan, __pyx_k_Calling_fuse_session_add_chan, sizeof(__pyx_k_Calling_fuse_session_add_chan), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_destroy, __pyx_k_Calling_fuse_session_destroy, sizeof(__pyx_k_Calling_fuse_session_destroy), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_loop, __pyx_k_Calling_fuse_session_loop, sizeof(__pyx_k_Calling_fuse_session_loop), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_loop_mt, __pyx_k_Calling_fuse_session_loop_mt, sizeof(__pyx_k_Calling_fuse_session_loop_mt), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_remove_chan, __pyx_k_Calling_fuse_session_remove_chan, sizeof(__pyx_k_Calling_fuse_session_remove_chan), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_set_signal_handlers, __pyx_k_Calling_fuse_set_signal_handlers, sizeof(__pyx_k_Calling_fuse_set_signal_handlers), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_unmount, __pyx_k_Calling_fuse_unmount, sizeof(__pyx_k_Calling_fuse_unmount), 0, 1, 0, 0}, {&__pyx_n_s_ENOATTR, __pyx_k_ENOATTR, sizeof(__pyx_k_ENOATTR), 0, 0, 1, 1}, {&__pyx_n_s_EntryAttributes, __pyx_k_EntryAttributes, sizeof(__pyx_k_EntryAttributes), 0, 0, 1, 1}, {&__pyx_kp_u_Exception_after_kill, __pyx_k_Exception_after_kill, sizeof(__pyx_k_Exception_after_kill), 0, 1, 0, 0}, {&__pyx_n_s_FUSEError, __pyx_k_FUSEError, sizeof(__pyx_k_FUSEError), 0, 0, 1, 1}, {&__pyx_kp_u_Global_lock_cannot_be_acquired_m, __pyx_k_Global_lock_cannot_be_acquired_m, sizeof(__pyx_k_Global_lock_cannot_be_acquired_m), 0, 1, 0, 0}, {&__pyx_kp_u_Initializing_llfuse, __pyx_k_Initializing_llfuse, sizeof(__pyx_k_Initializing_llfuse), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_can_only_be_released_by_the, __pyx_k_Lock_can_only_be_released_by_the, sizeof(__pyx_k_Lock_can_only_be_released_by_the), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_not_initialized, __pyx_k_Lock_not_initialized, sizeof(__pyx_k_Lock_not_initialized), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_still_taken_after_receiving, __pyx_k_Lock_still_taken_after_receiving, sizeof(__pyx_k_Lock_still_taken_after_receiving), 0, 1, 0, 0}, {&__pyx_kp_u_Need_to_call_init_before_main, __pyx_k_Need_to_call_init_before_main, sizeof(__pyx_k_Need_to_call_init_before_main), 0, 1, 0, 0}, {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1}, {&__pyx_n_s_Operations, __pyx_k_Operations, sizeof(__pyx_k_Operations), 0, 0, 1, 1}, {&__pyx_kp_u_Other_thread_didn_t_take_lock, __pyx_k_Other_thread_didn_t_take_lock, sizeof(__pyx_k_Other_thread_didn_t_take_lock), 0, 1, 0, 0}, {&__pyx_kp_b_Python_LLFUSE, __pyx_k_Python_LLFUSE, sizeof(__pyx_k_Python_LLFUSE), 0, 0, 0, 0}, {&__pyx_n_s_Queue, __pyx_k_Queue, sizeof(__pyx_k_Queue), 0, 0, 1, 1}, {&__pyx_n_s_ROOT_INODE, __pyx_k_ROOT_INODE, sizeof(__pyx_k_ROOT_INODE), 0, 0, 1, 1}, {&__pyx_n_s_RequestContext, __pyx_k_RequestContext, sizeof(__pyx_k_RequestContext), 0, 0, 1, 1}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_kp_u_Terminated_main_loop_because_req, __pyx_k_Terminated_main_loop_because_req, sizeof(__pyx_k_Terminated_main_loop_because_req), 0, 1, 0, 0}, {&__pyx_n_s_Thread, __pyx_k_Thread, sizeof(__pyx_k_Thread), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_kp_u_Weird_request_received_r, __pyx_k_Weird_request_received_r, sizeof(__pyx_k_Weird_request_received_r), 0, 1, 0, 0}, {&__pyx_kp_u_You_should_not_instantiate_this, __pyx_k_You_should_not_instantiate_this, sizeof(__pyx_k_You_should_not_instantiate_this), 0, 1, 0, 0}, {&__pyx_kp_b__28, __pyx_k__28, sizeof(__pyx_k__28), 0, 0, 0, 0}, {&__pyx_n_s_abspath, __pyx_k_abspath, sizeof(__pyx_k_abspath), 0, 0, 1, 1}, {&__pyx_n_s_access, __pyx_k_access, sizeof(__pyx_k_access), 0, 0, 1, 1}, {&__pyx_n_s_acquire, __pyx_k_acquire, sizeof(__pyx_k_acquire), 0, 0, 1, 1}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_attr_only, __pyx_k_attr_only, sizeof(__pyx_k_attr_only), 0, 0, 1, 1}, {&__pyx_n_u_attr_only, __pyx_k_attr_only, sizeof(__pyx_k_attr_only), 0, 1, 0, 1}, {&__pyx_n_s_attr_timeout, __pyx_k_attr_timeout, sizeof(__pyx_k_attr_timeout), 0, 0, 1, 1}, {&__pyx_n_s_block, __pyx_k_block, sizeof(__pyx_k_block), 0, 0, 1, 1}, {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1}, {&__pyx_n_s_bufsize, __pyx_k_bufsize, sizeof(__pyx_k_bufsize), 0, 0, 1, 1}, {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, {&__pyx_n_s_cname, __pyx_k_cname, sizeof(__pyx_k_cname), 0, 0, 1, 1}, {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, {&__pyx_n_s_cpath, __pyx_k_cpath, sizeof(__pyx_k_cpath), 0, 0, 1, 1}, {&__pyx_n_s_create, __pyx_k_create, sizeof(__pyx_k_create), 0, 0, 1, 1}, {&__pyx_n_s_cvalue, __pyx_k_cvalue, sizeof(__pyx_k_cvalue), 0, 0, 1, 1}, {&__pyx_n_s_daemon, __pyx_k_daemon, sizeof(__pyx_k_daemon), 0, 0, 1, 1}, {&__pyx_n_s_debug, __pyx_k_debug, sizeof(__pyx_k_debug), 0, 0, 1, 1}, {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, {&__pyx_n_s_destroy, __pyx_k_destroy, sizeof(__pyx_k_destroy), 0, 0, 1, 1}, {&__pyx_n_s_dirp, __pyx_k_dirp, sizeof(__pyx_k_dirp), 0, 0, 1, 1}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_ent, __pyx_k_ent, sizeof(__pyx_k_ent), 0, 0, 1, 1}, {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, {&__pyx_n_s_entry_timeout, __pyx_k_entry_timeout, sizeof(__pyx_k_entry_timeout), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_errno, __pyx_k_errno, sizeof(__pyx_k_errno), 0, 0, 1, 1}, {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_exc_info, __pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 0, 1, 1}, {&__pyx_n_s_exc_tb, __pyx_k_exc_tb, sizeof(__pyx_k_exc_tb), 0, 0, 1, 1}, {&__pyx_n_s_exc_type, __pyx_k_exc_type, sizeof(__pyx_k_exc_type), 0, 0, 1, 1}, {&__pyx_n_s_exc_val, __pyx_k_exc_val, sizeof(__pyx_k_exc_val), 0, 0, 1, 1}, {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, {&__pyx_n_s_f_args, __pyx_k_f_args, sizeof(__pyx_k_f_args), 0, 0, 1, 1}, {&__pyx_n_s_f_bavail, __pyx_k_f_bavail, sizeof(__pyx_k_f_bavail), 0, 0, 1, 1}, {&__pyx_n_s_f_bfree, __pyx_k_f_bfree, sizeof(__pyx_k_f_bfree), 0, 0, 1, 1}, {&__pyx_n_s_f_blocks, __pyx_k_f_blocks, sizeof(__pyx_k_f_blocks), 0, 0, 1, 1}, {&__pyx_n_s_f_bsize, __pyx_k_f_bsize, sizeof(__pyx_k_f_bsize), 0, 0, 1, 1}, {&__pyx_n_s_f_favail, __pyx_k_f_favail, sizeof(__pyx_k_f_favail), 0, 0, 1, 1}, {&__pyx_n_s_f_ffree, __pyx_k_f_ffree, sizeof(__pyx_k_f_ffree), 0, 0, 1, 1}, {&__pyx_n_s_f_files, __pyx_k_f_files, sizeof(__pyx_k_f_files), 0, 0, 1, 1}, {&__pyx_n_s_f_frsize, __pyx_k_f_frsize, sizeof(__pyx_k_f_frsize), 0, 0, 1, 1}, {&__pyx_n_s_flush, __pyx_k_flush, sizeof(__pyx_k_flush), 0, 0, 1, 1}, {&__pyx_n_s_forget, __pyx_k_forget, sizeof(__pyx_k_forget), 0, 0, 1, 1}, {&__pyx_n_s_fse, __pyx_k_fse, sizeof(__pyx_k_fse), 0, 0, 1, 1}, {&__pyx_n_s_fsync, __pyx_k_fsync, sizeof(__pyx_k_fsync), 0, 0, 1, 1}, {&__pyx_n_s_fsyncdir, __pyx_k_fsyncdir, sizeof(__pyx_k_fsyncdir), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_access_fuse_reply__failed_w, __pyx_k_fuse_access_fuse_reply__failed_w, sizeof(__pyx_k_fuse_access_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_create_fuse_reply__failed_w, __pyx_k_fuse_create_fuse_reply__failed_w, sizeof(__pyx_k_fuse_create_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_flush_fuse_reply__failed_wi, __pyx_k_fuse_flush_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_flush_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi, __pyx_k_fuse_fsync_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_fsync_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed, __pyx_k_fuse_fsyncdir_fuse_reply__failed, sizeof(__pyx_k_fuse_fsyncdir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_getattr_fuse_reply__failed, __pyx_k_fuse_getattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_getxattr_fuse_reply__failed, __pyx_k_fuse_getxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_getxattr_non_zero_position, __pyx_k_fuse_getxattr_non_zero_position, sizeof(__pyx_k_fuse_getxattr_non_zero_position), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_k_fuse_link_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_link_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_listxattr_fuse_reply__faile, __pyx_k_fuse_listxattr_fuse_reply__faile, sizeof(__pyx_k_fuse_listxattr_fuse_reply__faile), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lookup_fuse_reply__failed_w, __pyx_k_fuse_lookup_fuse_reply__failed_w, sizeof(__pyx_k_fuse_lookup_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lowlevel_new_failed, __pyx_k_fuse_lowlevel_new_failed, sizeof(__pyx_k_fuse_lowlevel_new_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi, __pyx_k_fuse_mkdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mkdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi, __pyx_k_fuse_mknod_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mknod_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mount_failed, __pyx_k_fuse_mount_failed, sizeof(__pyx_k_fuse_mount_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_opendir_fuse_reply__failed, __pyx_k_fuse_opendir_fuse_reply__failed, sizeof(__pyx_k_fuse_opendir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_options_must_be_of_type_str, __pyx_k_fuse_options_must_be_of_type_str, sizeof(__pyx_k_fuse_options_must_be_of_type_str), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_read_fuse_reply__failed_wit, __pyx_k_fuse_read_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_read_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_readdir_fuse_reply__failed, __pyx_k_fuse_readdir_fuse_reply__failed, sizeof(__pyx_k_fuse_readdir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_readlink_fuse_reply__failed, __pyx_k_fuse_readlink_fuse_reply__failed, sizeof(__pyx_k_fuse_readlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_release_fuse_reply__failed, __pyx_k_fuse_release_fuse_reply__failed, sizeof(__pyx_k_fuse_release_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_releasedir_fuse_reply__fail, __pyx_k_fuse_releasedir_fuse_reply__fail, sizeof(__pyx_k_fuse_releasedir_fuse_reply__fail), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_removexattr_fuse_reply__fai, __pyx_k_fuse_removexattr_fuse_reply__fai, sizeof(__pyx_k_fuse_removexattr_fuse_reply__fai), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_rename_fuse_reply__failed_w, __pyx_k_fuse_rename_fuse_reply__failed_w, sizeof(__pyx_k_fuse_rename_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi, __pyx_k_fuse_rmdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_rmdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_loop_failed, __pyx_k_fuse_session_loop_failed, sizeof(__pyx_k_fuse_session_loop_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_loop_mt_failed, __pyx_k_fuse_session_loop_mt_failed, sizeof(__pyx_k_fuse_session_loop_mt_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_set_signal_handlers_failed, __pyx_k_fuse_set_signal_handlers_failed, sizeof(__pyx_k_fuse_set_signal_handlers_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK, __pyx_k_fuse_setattr_clock_gettime_CLOCK, sizeof(__pyx_k_fuse_setattr_clock_gettime_CLOCK), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setattr_fuse_reply__failed, __pyx_k_fuse_setattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setxattr_fuse_reply__failed, __pyx_k_fuse_setxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setxattr_fuse_reply_err_fai, __pyx_k_fuse_setxattr_fuse_reply_err_fai, sizeof(__pyx_k_fuse_setxattr_fuse_reply_err_fai), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setxattr_non_zero_position, __pyx_k_fuse_setxattr_non_zero_position, sizeof(__pyx_k_fuse_setxattr_non_zero_position), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_statfs_fuse_reply__failed_w, __pyx_k_fuse_statfs_fuse_reply__failed_w, sizeof(__pyx_k_fuse_statfs_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_symlink_fuse_reply__failed, __pyx_k_fuse_symlink_fuse_reply__failed, sizeof(__pyx_k_fuse_symlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_unlink_fuse_reply__failed_w, __pyx_k_fuse_unlink_fuse_reply__failed_w, sizeof(__pyx_k_fuse_unlink_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_err_d_fail, __pyx_k_fuse_write_fuse_reply_err_d_fail, sizeof(__pyx_k_fuse_write_fuse_reply_err_d_fail), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_err_failed, __pyx_k_fuse_write_fuse_reply_err_failed, sizeof(__pyx_k_fuse_write_fuse_reply_err_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_write_fail, __pyx_k_fuse_write_fuse_reply_write_fail, sizeof(__pyx_k_fuse_write_fuse_reply_write_fail), 0, 1, 0, 0}, {&__pyx_n_s_generation, __pyx_k_generation, sizeof(__pyx_k_generation), 0, 0, 1, 1}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_getLogger, __pyx_k_getLogger, sizeof(__pyx_k_getLogger), 0, 0, 1, 1}, {&__pyx_n_s_get_ino_t_bits, __pyx_k_get_ino_t_bits, sizeof(__pyx_k_get_ino_t_bits), 0, 0, 1, 1}, {&__pyx_n_s_get_off_t_bits, __pyx_k_get_off_t_bits, sizeof(__pyx_k_get_off_t_bits), 0, 0, 1, 1}, {&__pyx_n_s_getattr, __pyx_k_getattr, sizeof(__pyx_k_getattr), 0, 0, 1, 1}, {&__pyx_n_s_getfilesystemencoding, __pyx_k_getfilesystemencoding, sizeof(__pyx_k_getfilesystemencoding), 0, 0, 1, 1}, {&__pyx_n_s_getxattr, __pyx_k_getxattr, sizeof(__pyx_k_getxattr), 0, 0, 1, 1}, {&__pyx_n_s_gid, __pyx_k_gid, sizeof(__pyx_k_gid), 0, 0, 1, 1}, {&__pyx_kp_u_handler_raised_exception_sending, __pyx_k_handler_raised_exception_sending, sizeof(__pyx_k_handler_raised_exception_sending), 0, 1, 0, 0}, {&__pyx_kp_s_home_nikratio_in_progress_pytho, __pyx_k_home_nikratio_in_progress_pytho, sizeof(__pyx_k_home_nikratio_in_progress_pytho), 0, 0, 1, 0}, {&__pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_k_home_nikratio_in_progress_pytho_2, sizeof(__pyx_k_home_nikratio_in_progress_pytho_2), 0, 0, 1, 0}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, {&__pyx_n_s_ino, __pyx_k_ino, sizeof(__pyx_k_ino), 0, 0, 1, 1}, {&__pyx_n_s_inode, __pyx_k_inode, sizeof(__pyx_k_inode), 0, 0, 1, 1}, {&__pyx_n_u_inode, __pyx_k_inode, sizeof(__pyx_k_inode), 0, 1, 0, 1}, {&__pyx_n_s_inode_p, __pyx_k_inode_p, sizeof(__pyx_k_inode_p), 0, 0, 1, 1}, {&__pyx_n_u_inode_p, __pyx_k_inode_p, sizeof(__pyx_k_inode_p), 0, 1, 0, 1}, {&__pyx_n_s_inval_entry_req, __pyx_k_inval_entry_req, sizeof(__pyx_k_inval_entry_req), 0, 0, 1, 1}, {&__pyx_n_u_inval_entry_req, __pyx_k_inval_entry_req, sizeof(__pyx_k_inval_entry_req), 0, 1, 0, 1}, {&__pyx_n_s_inval_inode_req, __pyx_k_inval_inode_req, sizeof(__pyx_k_inval_inode_req), 0, 0, 1, 1}, {&__pyx_n_u_inval_inode_req, __pyx_k_inval_inode_req, sizeof(__pyx_k_inval_inode_req), 0, 1, 0, 1}, {&__pyx_n_s_invalidate_entry, __pyx_k_invalidate_entry, sizeof(__pyx_k_invalidate_entry), 0, 0, 1, 1}, {&__pyx_n_s_invalidate_inode, __pyx_k_invalidate_inode, sizeof(__pyx_k_invalidate_inode), 0, 0, 1, 1}, {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, {&__pyx_n_s_link, __pyx_k_link, sizeof(__pyx_k_link), 0, 0, 1, 1}, {&__pyx_n_s_listdir, __pyx_k_listdir, sizeof(__pyx_k_listdir), 0, 0, 1, 1}, {&__pyx_n_s_listxattr, __pyx_k_listxattr, sizeof(__pyx_k_listxattr), 0, 0, 1, 1}, {&__pyx_n_u_llfuse, __pyx_k_llfuse, sizeof(__pyx_k_llfuse), 0, 1, 0, 1}, {&__pyx_n_s_llfuse_capi, __pyx_k_llfuse_capi, sizeof(__pyx_k_llfuse_capi), 0, 0, 1, 1}, {&__pyx_n_s_llfuse_pyapi, __pyx_k_llfuse_pyapi, sizeof(__pyx_k_llfuse_pyapi), 0, 0, 1, 1}, {&__pyx_n_s_lock, __pyx_k_lock, sizeof(__pyx_k_lock), 0, 0, 1, 1}, {&__pyx_n_s_lock_released, __pyx_k_lock_released, sizeof(__pyx_k_lock_released), 0, 0, 1, 1}, {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1}, {&__pyx_n_s_logging, __pyx_k_logging, sizeof(__pyx_k_logging), 0, 0, 1, 1}, {&__pyx_n_s_lookup, __pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_main_2, __pyx_k_main_2, sizeof(__pyx_k_main_2), 0, 0, 1, 1}, {&__pyx_n_s_maxsize, __pyx_k_maxsize, sizeof(__pyx_k_maxsize), 0, 0, 1, 1}, {&__pyx_n_s_mkdir, __pyx_k_mkdir, sizeof(__pyx_k_mkdir), 0, 0, 1, 1}, {&__pyx_n_s_mknod, __pyx_k_mknod, sizeof(__pyx_k_mknod), 0, 0, 1, 1}, {&__pyx_n_s_mountpoint, __pyx_k_mountpoint, sizeof(__pyx_k_mountpoint), 0, 0, 1, 1}, {&__pyx_kp_u_mountpoint__argument_must_be_of, __pyx_k_mountpoint__argument_must_be_of, sizeof(__pyx_k_mountpoint__argument_must_be_of), 0, 1, 0, 0}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, {&__pyx_kp_u_name_argument_must_be_of_type_s, __pyx_k_name_argument_must_be_of_type_s, sizeof(__pyx_k_name_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_name_b, __pyx_k_name_b, sizeof(__pyx_k_name_b), 0, 0, 1, 1}, {&__pyx_n_s_namedtuple, __pyx_k_namedtuple, sizeof(__pyx_k_namedtuple), 0, 0, 1, 1}, {&__pyx_n_s_names, __pyx_k_names, sizeof(__pyx_k_names), 0, 0, 1, 1}, {&__pyx_n_s_namespace, __pyx_k_namespace, sizeof(__pyx_k_namespace), 0, 0, 1, 1}, {&__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_k_namespace_parameter_must_be_sys, sizeof(__pyx_k_namespace_parameter_must_be_sys), 0, 1, 0, 0}, {&__pyx_n_s_notify_loop, __pyx_k_notify_loop, sizeof(__pyx_k_notify_loop), 0, 0, 1, 1}, {&__pyx_n_s_notify_queue, __pyx_k_notify_queue, sizeof(__pyx_k_notify_queue), 0, 0, 1, 1}, {&__pyx_kp_b_o, __pyx_k_o, sizeof(__pyx_k_o), 0, 0, 0, 0}, {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, {&__pyx_n_s_opendir, __pyx_k_opendir, sizeof(__pyx_k_opendir), 0, 0, 1, 1}, {&__pyx_n_s_ops, __pyx_k_ops, sizeof(__pyx_k_ops), 0, 0, 1, 1}, {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, {&__pyx_n_s_os_path, __pyx_k_os_path, sizeof(__pyx_k_os_path), 0, 0, 1, 1}, {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, {&__pyx_kp_u_path_argument_must_be_of_type_s, __pyx_k_path_argument_must_be_of_type_s, sizeof(__pyx_k_path_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_path_b, __pyx_k_path_b, sizeof(__pyx_k_path_b), 0, 0, 1, 1}, {&__pyx_n_s_pid, __pyx_k_pid, sizeof(__pyx_k_pid), 0, 0, 1, 1}, {&__pyx_n_s_put, __pyx_k_put, sizeof(__pyx_k_put), 0, 0, 1, 1}, {&__pyx_n_s_queue, __pyx_k_queue, sizeof(__pyx_k_queue), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1}, {&__pyx_n_s_readdir, __pyx_k_readdir, sizeof(__pyx_k_readdir), 0, 0, 1, 1}, {&__pyx_n_s_readlink, __pyx_k_readlink, sizeof(__pyx_k_readlink), 0, 0, 1, 1}, {&__pyx_n_s_release, __pyx_k_release, sizeof(__pyx_k_release), 0, 0, 1, 1}, {&__pyx_n_s_releasedir, __pyx_k_releasedir, sizeof(__pyx_k_releasedir), 0, 0, 1, 1}, {&__pyx_n_s_removexattr, __pyx_k_removexattr, sizeof(__pyx_k_removexattr), 0, 0, 1, 1}, {&__pyx_n_s_rename, __pyx_k_rename, sizeof(__pyx_k_rename), 0, 0, 1, 1}, {&__pyx_n_s_req, __pyx_k_req, sizeof(__pyx_k_req), 0, 0, 1, 1}, {&__pyx_n_s_res, __pyx_k_res, sizeof(__pyx_k_res), 0, 0, 1, 1}, {&__pyx_n_s_ret, __pyx_k_ret, sizeof(__pyx_k_ret), 0, 0, 1, 1}, {&__pyx_n_s_rmdir, __pyx_k_rmdir, sizeof(__pyx_k_rmdir), 0, 0, 1, 1}, {&__pyx_n_s_setattr, __pyx_k_setattr, sizeof(__pyx_k_setattr), 0, 0, 1, 1}, {&__pyx_n_s_setxattr, __pyx_k_setxattr, sizeof(__pyx_k_setxattr), 0, 0, 1, 1}, {&__pyx_n_s_single, __pyx_k_single, sizeof(__pyx_k_single), 0, 0, 1, 1}, {&__pyx_n_s_size_guess, __pyx_k_size_guess, sizeof(__pyx_k_size_guess), 0, 0, 1, 1}, {&__pyx_n_s_st_atime, __pyx_k_st_atime, sizeof(__pyx_k_st_atime), 0, 0, 1, 1}, {&__pyx_n_s_st_atime_ns, __pyx_k_st_atime_ns, sizeof(__pyx_k_st_atime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_blksize, __pyx_k_st_blksize, sizeof(__pyx_k_st_blksize), 0, 0, 1, 1}, {&__pyx_n_s_st_blocks, __pyx_k_st_blocks, sizeof(__pyx_k_st_blocks), 0, 0, 1, 1}, {&__pyx_n_s_st_ctime, __pyx_k_st_ctime, sizeof(__pyx_k_st_ctime), 0, 0, 1, 1}, {&__pyx_n_s_st_ctime_ns, __pyx_k_st_ctime_ns, sizeof(__pyx_k_st_ctime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_gid, __pyx_k_st_gid, sizeof(__pyx_k_st_gid), 0, 0, 1, 1}, {&__pyx_n_s_st_ino, __pyx_k_st_ino, sizeof(__pyx_k_st_ino), 0, 0, 1, 1}, {&__pyx_n_s_st_mode, __pyx_k_st_mode, sizeof(__pyx_k_st_mode), 0, 0, 1, 1}, {&__pyx_n_s_st_mtime, __pyx_k_st_mtime, sizeof(__pyx_k_st_mtime), 0, 0, 1, 1}, {&__pyx_n_s_st_mtime_ns, __pyx_k_st_mtime_ns, sizeof(__pyx_k_st_mtime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_nlink, __pyx_k_st_nlink, sizeof(__pyx_k_st_nlink), 0, 0, 1, 1}, {&__pyx_n_s_st_rdev, __pyx_k_st_rdev, sizeof(__pyx_k_st_rdev), 0, 0, 1, 1}, {&__pyx_n_s_st_size, __pyx_k_st_size, sizeof(__pyx_k_st_size), 0, 0, 1, 1}, {&__pyx_n_s_st_uid, __pyx_k_st_uid, sizeof(__pyx_k_st_uid), 0, 0, 1, 1}, {&__pyx_n_s_stacktrace, __pyx_k_stacktrace, sizeof(__pyx_k_stacktrace), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_statfs, __pyx_k_statfs, sizeof(__pyx_k_statfs), 0, 0, 1, 1}, {&__pyx_n_s_str_t, __pyx_k_str_t, sizeof(__pyx_k_str_t), 0, 0, 1, 1}, {&__pyx_n_s_strerror, __pyx_k_strerror, sizeof(__pyx_k_strerror), 0, 0, 1, 1}, {&__pyx_n_u_surrogateescape, __pyx_k_surrogateescape, sizeof(__pyx_k_surrogateescape), 0, 1, 0, 1}, {&__pyx_n_s_symlink, __pyx_k_symlink, sizeof(__pyx_k_symlink), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_u_system, __pyx_k_system, sizeof(__pyx_k_system), 0, 1, 0, 1}, {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, {&__pyx_n_s_tmp, __pyx_k_tmp, sizeof(__pyx_k_tmp), 0, 0, 1, 1}, {&__pyx_n_s_uid, __pyx_k_uid, sizeof(__pyx_k_uid), 0, 0, 1, 1}, {&__pyx_n_s_umask, __pyx_k_umask, sizeof(__pyx_k_umask), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_flag_s_o, __pyx_k_unknown_flag_s_o, sizeof(__pyx_k_unknown_flag_s_o), 0, 1, 0, 0}, {&__pyx_n_s_unlink, __pyx_k_unlink, sizeof(__pyx_k_unlink), 0, 0, 1, 1}, {&__pyx_n_s_unmount, __pyx_k_unmount, sizeof(__pyx_k_unmount), 0, 0, 1, 1}, {&__pyx_kp_u_us_ascii, __pyx_k_us_ascii, sizeof(__pyx_k_us_ascii), 0, 1, 0, 0}, {&__pyx_n_u_user, __pyx_k_user, sizeof(__pyx_k_user), 0, 1, 0, 1}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, {&__pyx_n_s_with_traceback, __pyx_k_with_traceback, sizeof(__pyx_k_with_traceback), 0, 0, 1, 1}, {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_BaseException = __Pyx_GetBuiltinName(__pyx_n_s_BaseException); if (!__pyx_builtin_BaseException) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ __pyx_tuple_ = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "src/llfuse/handlers.pxi":32 * exc_info = sys.exc_info() * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Exception_after_kill); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ __pyx_tuple__3 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ __pyx_tuple__4 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ __pyx_tuple__5 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ __pyx_tuple__6 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ __pyx_tuple__7 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ __pyx_tuple__8 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ __pyx_tuple__9 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__10 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__11 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ __pyx_tuple__12 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ __pyx_tuple__13 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ __pyx_tuple__14 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ __pyx_tuple__15 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_tuple__16 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ __pyx_tuple__17 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__18 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__19 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__19); __Pyx_GIVEREF(__pyx_tuple__19); /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__20 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ __pyx_tuple__21 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ __pyx_tuple__22 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__23 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__24 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ __pyx_tuple__25 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "src/llfuse/handlers.pxi":555 * raise ValueError('unknown flag(s): %o' % flags) * * with lock: # <<<<<<<<<<<<<< * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: */ __pyx_tuple__26 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_tuple__27 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ __pyx_tuple__29 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__30 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ __pyx_tuple__31 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ __pyx_tuple__32 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); /* "src/llfuse/misc.pxi":79 * if not exc_info: * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') # <<<<<<<<<<<<<< * kill(getpid(), SIGTERM) * else: */ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_handler_raised_exception_sending); if (unlikely(!__pyx_tuple__33)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__33); __Pyx_GIVEREF(__pyx_tuple__33); /* "src/llfuse/misc.pxi":82 * kill(getpid(), SIGTERM) * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * if req is NULL: */ __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_Exception_after_kill); if (unlikely(!__pyx_tuple__34)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); /* "src/llfuse/misc.pxi":152 * for el in args: * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_fuse_options_must_be_of_type_str); if (unlikely(!__pyx_tuple__35)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); /* "src/llfuse/misc.pxi":154 * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) # <<<<<<<<<<<<<< * args = args_new * */ __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_us_ascii); if (unlikely(!__pyx_tuple__36)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); /* "src/llfuse/misc.pxi":192 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_u_You_should_not_instantiate_this); if (unlikely(!__pyx_tuple__37)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__37); __Pyx_GIVEREF(__pyx_tuple__37); /* "src/llfuse/misc.pxi":219 * return False * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_u_Global_lock_cannot_be_acquired_m); if (unlikely(!__pyx_tuple__38)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "src/llfuse/misc.pxi":221 * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_u_Lock_still_taken_after_receiving); if (unlikely(!__pyx_tuple__39)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__39); __Pyx_GIVEREF(__pyx_tuple__39); /* "src/llfuse/misc.pxi":223 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__40)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); /* "src/llfuse/misc.pxi":237 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_u_Lock_can_only_be_released_by_the); if (unlikely(!__pyx_tuple__41)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__41); __Pyx_GIVEREF(__pyx_tuple__41); /* "src/llfuse/misc.pxi":239 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__42)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__42); __Pyx_GIVEREF(__pyx_tuple__42); /* "src/llfuse/misc.pxi":261 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_Lock_can_only_be_released_by_the); if (unlikely(!__pyx_tuple__43)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); /* "src/llfuse/misc.pxi":263 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") */ __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_u_Lock_still_taken_after_receiving); if (unlikely(!__pyx_tuple__44)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__44); __Pyx_GIVEREF(__pyx_tuple__44); /* "src/llfuse/misc.pxi":265 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_Other_thread_didn_t_take_lock); if (unlikely(!__pyx_tuple__45)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__45); __Pyx_GIVEREF(__pyx_tuple__45); /* "src/llfuse/misc.pxi":267 * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__46)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__46); __Pyx_GIVEREF(__pyx_tuple__46); /* "src/llfuse/misc.pxi":282 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_You_should_not_instantiate_this); if (unlikely(!__pyx_tuple__47)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); /* "src/llfuse/fuse_api.pxi":28 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef dirent.DIR* dirp */ __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__48)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__48); __Pyx_GIVEREF(__pyx_tuple__48); /* "src/llfuse/fuse_api.pxi":82 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__51)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); /* "src/llfuse/fuse_api.pxi":85 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_name_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__52)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__52); __Pyx_GIVEREF(__pyx_tuple__52); /* "src/llfuse/fuse_api.pxi":144 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__53)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); /* "src/llfuse/fuse_api.pxi":147 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_u_name_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__54)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__54); __Pyx_GIVEREF(__pyx_tuple__54); /* "src/llfuse/fuse_api.pxi":231 * ''' * * log.debug('Initializing llfuse') # <<<<<<<<<<<<<< * cdef fuse_args f_args * */ __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_Initializing_llfuse); if (unlikely(!__pyx_tuple__55)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); /* "src/llfuse/fuse_api.pxi":235 * * if not isinstance(mountpoint, str_t): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_mountpoint__argument_must_be_of); if (unlikely(!__pyx_tuple__56)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); /* "src/llfuse/fuse_api.pxi":250 * * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') # <<<<<<<<<<<<<< * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: */ __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_mount); if (unlikely(!__pyx_tuple__57)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__57); __Pyx_GIVEREF(__pyx_tuple__57); /* "src/llfuse/fuse_api.pxi":253 * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: * raise RuntimeError('fuse_mount failed') # <<<<<<<<<<<<<< * * log.debug('Calling fuse_lowlevel_new') */ __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_u_fuse_mount_failed); if (unlikely(!__pyx_tuple__58)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); /* "src/llfuse/fuse_api.pxi":255 * raise RuntimeError('fuse_mount failed') * * log.debug('Calling fuse_lowlevel_new') # <<<<<<<<<<<<<< * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) */ __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_lowlevel_new); if (unlikely(!__pyx_tuple__59)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); /* "src/llfuse/fuse_api.pxi":260 * if not session: * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_set_signal_handlers') */ __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_u_fuse_lowlevel_new_failed); if (unlikely(!__pyx_tuple__60)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__60); __Pyx_GIVEREF(__pyx_tuple__60); /* "src/llfuse/fuse_api.pxi":262 * raise RuntimeError("fuse_lowlevel_new() failed") * * log.debug('Calling fuse_set_signal_handlers') # <<<<<<<<<<<<<< * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) */ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_set_signal_handlers); if (unlikely(!__pyx_tuple__61)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); /* "src/llfuse/fuse_api.pxi":266 * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_add_chan') */ __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_u_fuse_set_signal_handlers_failed); if (unlikely(!__pyx_tuple__62)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); /* "src/llfuse/fuse_api.pxi":268 * raise RuntimeError("fuse_set_signal_handlers() failed") * * log.debug('Calling fuse_session_add_chan') # <<<<<<<<<<<<<< * fuse_session_add_chan(session, channel) * */ __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_add_chan); if (unlikely(!__pyx_tuple__63)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); /* "src/llfuse/fuse_api.pxi":283 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * # Start notification handling thread */ __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_u_Need_to_call_init_before_main); if (unlikely(!__pyx_tuple__64)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); /* "src/llfuse/fuse_api.pxi":293 * * if single: * log.debug('Calling fuse_session_loop') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop(session) */ __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_loop); if (unlikely(!__pyx_tuple__65)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); /* "src/llfuse/fuse_api.pxi":296 * with nogil: * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop failed") */ __pyx_tuple__66 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__66)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__66); __Pyx_GIVEREF(__pyx_tuple__66); /* "src/llfuse/fuse_api.pxi":298 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop failed") # <<<<<<<<<<<<<< * else: * log.debug('Calling fuse_session_loop_mt') */ __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_loop_failed); if (unlikely(!__pyx_tuple__67)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); /* "src/llfuse/fuse_api.pxi":300 * raise RuntimeError("fuse_session_loop failed") * else: * log.debug('Calling fuse_session_loop_mt') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop_mt(session) */ __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_loop_mt); if (unlikely(!__pyx_tuple__68)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__68); __Pyx_GIVEREF(__pyx_tuple__68); /* "src/llfuse/fuse_api.pxi":303 * with nogil: * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") */ __pyx_tuple__69 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__69)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); /* "src/llfuse/fuse_api.pxi":305 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") # <<<<<<<<<<<<<< * * if exc_info: */ __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_loop_mt_failed); if (unlikely(!__pyx_tuple__70)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__70); __Pyx_GIVEREF(__pyx_tuple__70); /* "src/llfuse/fuse_api.pxi":309 * if exc_info: * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_Terminated_main_loop_because_req); if (unlikely(!__pyx_tuple__71)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); /* "src/llfuse/fuse_api.pxi":335 * global exc_info * * log.debug('Calling fuse_session_remove_chan') # <<<<<<<<<<<<<< * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') */ __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_remove_chan); if (unlikely(!__pyx_tuple__72)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__72); __Pyx_GIVEREF(__pyx_tuple__72); /* "src/llfuse/fuse_api.pxi":337 * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') # <<<<<<<<<<<<<< * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') */ __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_remove_signal_handl); if (unlikely(!__pyx_tuple__73)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__73); __Pyx_GIVEREF(__pyx_tuple__73); /* "src/llfuse/fuse_api.pxi":339 * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') # <<<<<<<<<<<<<< * fuse_session_destroy(session) * */ __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_destroy); if (unlikely(!__pyx_tuple__74)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__74); __Pyx_GIVEREF(__pyx_tuple__74); /* "src/llfuse/fuse_api.pxi":343 * * if unmount: * log.debug('Calling fuse_unmount') # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * else: */ __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_unmount); if (unlikely(!__pyx_tuple__75)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__75); __Pyx_GIVEREF(__pyx_tuple__75); /* "llfuse/capi.pyx":93 * ################## * * log = logging.getLogger("llfuse") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __pyx_tuple__76 = PyTuple_Pack(1, __pyx_n_u_llfuse); if (unlikely(!__pyx_tuple__76)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__76); __Pyx_GIVEREF(__pyx_tuple__76); /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ __pyx_tuple__77 = PyTuple_Pack(4, __pyx_n_s_len, __pyx_n_s_ino, __pyx_n_s_cname, __pyx_n_s_req); if (unlikely(!__pyx_tuple__77)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__77); __Pyx_GIVEREF(__pyx_tuple__77); __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(0, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho, __pyx_n_s_notify_loop, 291, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_tuple__79 = PyTuple_Pack(8, __pyx_n_s_path, __pyx_n_s_dirp, __pyx_n_s_ent, __pyx_n_s_res, __pyx_n_s_ret, __pyx_n_s_buf, __pyx_n_s_path_b, __pyx_n_s_names); if (unlikely(!__pyx_tuple__79)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__79); __Pyx_GIVEREF(__pyx_tuple__79); __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__79, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_listdir, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_tuple__81 = PyTuple_Pack(11, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_len, __pyx_n_s_cvalue, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__81)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__81); __Pyx_GIVEREF(__pyx_tuple__81); __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(4, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_setxattr, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_tuple__83 = PyTuple_Pack(11, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_size_guess, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_buf, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_bufsize, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__83)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__83); __Pyx_GIVEREF(__pyx_tuple__83); __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(4, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__83, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_getxattr, 122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __pyx_tuple__85 = PyTuple_Pack(4, __pyx_n_s_ops, __pyx_n_s_mountpoint, __pyx_n_s_args, __pyx_n_s_f_args); if (unlikely(!__pyx_tuple__85)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__85); __Pyx_GIVEREF(__pyx_tuple__85); __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__85, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_init, 218, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ __pyx_tuple__87 = PyTuple_Pack(4, __pyx_n_s_single, __pyx_n_s_ret, __pyx_n_s_t, __pyx_n_s_tmp); if (unlikely(!__pyx_tuple__87)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__87); __Pyx_GIVEREF(__pyx_tuple__87); __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__87, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_main_2, 271, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ __pyx_tuple__89 = PyTuple_Pack(2, __pyx_n_s_unmount, __pyx_n_s_tmp); if (unlikely(!__pyx_tuple__89)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__89); __Pyx_GIVEREF(__pyx_tuple__89); __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__89, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_close, 321, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_tuple__91 = PyTuple_Pack(2, __pyx_n_s_inode, __pyx_n_s_attr_only); if (unlikely(!__pyx_tuple__91)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__91); __Pyx_GIVEREF(__pyx_tuple__91); __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__91, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_invalidate_inode, 365, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_tuple__93 = PyTuple_Pack(2, __pyx_n_s_inode_p, __pyx_n_s_name); if (unlikely(!__pyx_tuple__93)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__93); __Pyx_GIVEREF(__pyx_tuple__93); __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__93, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_invalidate_entry, 376, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_get_ino_t_bits, 387, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_get_off_t_bits, 395, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __pyx_float_1e9 = PyFloat_FromDouble(1e9); if (unlikely(!__pyx_float_1e9)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1000000000 = PyInt_FromLong(1000000000L); if (unlikely(!__pyx_int_1000000000)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC initcapi(void); /*proto*/ PyMODINIT_FUNC initcapi(void) #else PyMODINIT_FUNC PyInit_capi(void); /*proto*/ PyMODINIT_FUNC PyInit_capi(void) #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_capi(void)", 0); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("capi", __pyx_methods, __pyx_k_capi_pxy_Copyright_2013_Nikolau, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if (__pyx_module_is_main_llfuse__capi) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (!PyDict_GetItemString(modules, "llfuse.capi")) { if (unlikely(PyDict_SetItemString(modules, "llfuse.capi", __pyx_m) < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } #endif /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ __pyx_v_6llfuse_4capi_operations = Py_None; Py_INCREF(Py_None); __pyx_v_6llfuse_4capi_mountpoint_b = Py_None; Py_INCREF(Py_None); __pyx_v_6llfuse_4capi_exc_info = Py_None; Py_INCREF(Py_None); /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ if (PyType_Ready(&__pyx_type_6llfuse_4capi_Lock) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 185; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6llfuse_4capi_Lock.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "Lock", (PyObject *)&__pyx_type_6llfuse_4capi_Lock) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 185; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6llfuse_4capi_Lock = &__pyx_type_6llfuse_4capi_Lock; if (PyType_Ready(&__pyx_type_6llfuse_4capi_NoLockManager) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6llfuse_4capi_NoLockManager.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "NoLockManager", (PyObject *)&__pyx_type_6llfuse_4capi_NoLockManager) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6llfuse_4capi_NoLockManager = &__pyx_type_6llfuse_4capi_NoLockManager; /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "llfuse/capi.pyx":13 * cdef extern from *: * char* LLFUSE_VERSION * __version__ = LLFUSE_VERSION.decode('utf-8') # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_decode_c_string(LLFUSE_VERSION, 0, strlen(LLFUSE_VERSION), NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 13; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 13; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":74 * ################ * * import os # <<<<<<<<<<<<<< * import logging * import sys */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 74; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 74; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":75 * * import os * import logging # <<<<<<<<<<<<<< * import sys * import os.path */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_logging, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_logging, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":76 * import os * import logging * import sys # <<<<<<<<<<<<<< * import os.path * import threading */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":77 * import logging * import sys * import os.path # <<<<<<<<<<<<<< * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os_path, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":78 * import sys * import os.path * import threading # <<<<<<<<<<<<<< * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes * from collections import namedtuple */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_threading, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":79 * import os.path * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes # <<<<<<<<<<<<<< * from collections import namedtuple * */ __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_FUSEError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_FUSEError); __Pyx_GIVEREF(__pyx_n_s_FUSEError); __Pyx_INCREF(__pyx_n_s_strerror); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_strerror); __Pyx_GIVEREF(__pyx_n_s_strerror); __Pyx_INCREF(__pyx_n_s_Operations); PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_Operations); __Pyx_GIVEREF(__pyx_n_s_Operations); __Pyx_INCREF(__pyx_n_s_RequestContext); PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_RequestContext); __Pyx_GIVEREF(__pyx_n_s_RequestContext); __Pyx_INCREF(__pyx_n_s_EntryAttributes); PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_EntryAttributes); __Pyx_GIVEREF(__pyx_n_s_EntryAttributes); __pyx_t_2 = __Pyx_Import(__pyx_n_s_llfuse_pyapi, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FUSEError); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FUSEError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_strerror, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Operations); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Operations, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_RequestContext); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_RequestContext, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_EntryAttributes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_EntryAttributes, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":80 * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes * from collections import namedtuple # <<<<<<<<<<<<<< * * if PY_MAJOR_VERSION < 3: */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_namedtuple); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_namedtuple); __Pyx_GIVEREF(__pyx_n_s_namedtuple); __pyx_t_1 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_namedtuple); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_namedtuple, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":82 * from collections import namedtuple * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * from Queue import Queue * str_t = bytes */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "llfuse/capi.pyx":83 * * if PY_MAJOR_VERSION < 3: * from Queue import Queue # <<<<<<<<<<<<<< * str_t = bytes * else: */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Queue); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Queue); __Pyx_GIVEREF(__pyx_n_s_Queue); __pyx_t_2 = __Pyx_Import(__pyx_n_s_Queue, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Queue, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":84 * if PY_MAJOR_VERSION < 3: * from Queue import Queue * str_t = bytes # <<<<<<<<<<<<<< * else: * from queue import Queue */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_t, ((PyObject *)((PyObject*)(&PyBytes_Type)))) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L2; } /*else*/ { /* "llfuse/capi.pyx":86 * str_t = bytes * else: * from queue import Queue # <<<<<<<<<<<<<< * str_t = str * */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_Queue); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Queue); __Pyx_GIVEREF(__pyx_n_s_Queue); __pyx_t_1 = __Pyx_Import(__pyx_n_s_queue, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Queue, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":87 * else: * from queue import Queue * str_t = str # <<<<<<<<<<<<<< * * ################## */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_t, ((PyObject *)((PyObject*)(&PyUnicode_Type)))) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_L2:; /* "llfuse/capi.pyx":93 * ################## * * log = logging.getLogger("llfuse") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_logging); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getLogger); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_log, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":94 * * log = logging.getLogger("llfuse") * fse = sys.getfilesystemencoding() # <<<<<<<<<<<<<< * * cdef object operations */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getfilesystemencoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_fse, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":98 * cdef object operations * cdef object mountpoint_b * cdef fuse_session* session = NULL # <<<<<<<<<<<<<< * cdef fuse_chan* channel = NULL * cdef fuse_lowlevel_ops fuse_ops */ __pyx_v_6llfuse_4capi_session = NULL; /* "llfuse/capi.pyx":99 * cdef object mountpoint_b * cdef fuse_session* session = NULL * cdef fuse_chan* channel = NULL # <<<<<<<<<<<<<< * cdef fuse_lowlevel_ops fuse_ops * cdef object exc_info */ __pyx_v_6llfuse_4capi_channel = NULL; /* "llfuse/capi.pyx":103 * cdef object exc_info * * init_lock() # <<<<<<<<<<<<<< * lock = Lock.__new__(Lock) * lock_released = NoLockManager.__new__(NoLockManager) */ init_lock(); /* "llfuse/capi.pyx":104 * * init_lock() * lock = Lock.__new__(Lock) # <<<<<<<<<<<<<< * lock_released = NoLockManager.__new__(NoLockManager) * */ __pyx_t_1 = __pyx_tp_new_6llfuse_4capi_Lock(((PyTypeObject *)((PyObject*)__pyx_ptype_6llfuse_4capi_Lock)), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_lock, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":105 * init_lock() * lock = Lock.__new__(Lock) * lock_released = NoLockManager.__new__(NoLockManager) # <<<<<<<<<<<<<< * * _notify_queue = Queue(maxsize=1000) */ __pyx_t_1 = __pyx_tp_new_6llfuse_4capi_NoLockManager(((PyTypeObject *)((PyObject*)__pyx_ptype_6llfuse_4capi_NoLockManager)), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_lock_released, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":107 * lock_released = NoLockManager.__new__(NoLockManager) * * _notify_queue = Queue(maxsize=1000) # <<<<<<<<<<<<<< * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_maxsize, __pyx_int_1000) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_queue, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":108 * * _notify_queue = Queue(maxsize=1000) * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) # <<<<<<<<<<<<<< * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) * */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_namedtuple); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_inode); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_inode); __Pyx_GIVEREF(__pyx_n_u_inode); __Pyx_INCREF(__pyx_n_u_attr_only); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_u_attr_only); __Pyx_GIVEREF(__pyx_n_u_attr_only); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_n_u_inval_inode_req); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_n_u_inval_inode_req); __Pyx_GIVEREF(__pyx_n_u_inval_inode_req); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_inval_inode_req, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":109 * _notify_queue = Queue(maxsize=1000) * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) # <<<<<<<<<<<<<< * * # Exported for access from Python code */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_namedtuple); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = PyList_New(2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_n_u_inode_p); PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_u_inode_p); __Pyx_GIVEREF(__pyx_n_u_inode_p); __Pyx_INCREF(__pyx_n_u_name); PyList_SET_ITEM(__pyx_t_7, 1, __pyx_n_u_name); __Pyx_GIVEREF(__pyx_n_u_name); __pyx_t_1 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_1) { PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = NULL; } __Pyx_INCREF(__pyx_n_u_inval_entry_req); PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_n_u_inval_entry_req); __Pyx_GIVEREF(__pyx_n_u_inval_entry_req); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_inval_entry_req, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":112 * * # Exported for access from Python code * ROOT_INODE = FUSE_ROOT_ID # <<<<<<<<<<<<<< * ENOATTR = errno.ENOATTR * */ __pyx_t_2 = __Pyx_PyInt_From_int(FUSE_ROOT_ID); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROOT_INODE, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":113 * # Exported for access from Python code * ROOT_INODE = FUSE_ROOT_ID * ENOATTR = errno.ENOATTR # <<<<<<<<<<<<<< * * ####################### */ __pyx_t_2 = __Pyx_PyInt_From_int(ENOATTR); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENOATTR, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_1_notify_loop, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_loop, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_3listdir, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_listdir, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_5setxattr, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setxattr, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_7getxattr, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_getxattr, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_9init, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_init, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_11main, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_main_2, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_13close, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_close, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_15invalidate_inode, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_inode, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_17invalidate_entry, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_entry, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_19get_ino_t_bits, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_ino_t_bits, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_21get_off_t_bits, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_off_t_bits, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":1 * ''' # <<<<<<<<<<<<<< * capi.pxy * */ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "xattr.pxd":32 * return c_setxattr(path, name, value, size, flags, 0) * * cdef inline int getxattr (char *path, char *name, # <<<<<<<<<<<<<< * void *value, int size) nogil: * return c_getxattr(path, name, value, size, 0, 0) */ /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init llfuse.capi", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init llfuse.capi"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif } /* Runtime support code */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule((char *)modname); if (!m) goto end; p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON result = PyDict_GetItem(__pyx_d, name); if (likely(result)) { Py_INCREF(result); } else { #else result = PyObject_GetItem(__pyx_d, name); if (!result) { PyErr_Clear(); #endif result = __Pyx_GetBuiltinName(name); } return result; } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject* args = PyTuple_Pack(1, arg); return (likely(args)) ? __Pyx_PyObject_Call(func, args, NULL) : NULL; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else PyErr_GetExcInfo(type, value, tb); #endif } static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(type, value, tb); #endif } static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { PyObject *local_type, *local_value, *local_tb; #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_COMPILING_IN_CPYTHON tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_Restore(type, value, tb); #endif } static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(type, value, tb); #endif } static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } } static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #else PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { if (PyObject_IsSubclass(instance_class, type)) { type = instance_class; } else { instance_class = NULL; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } #if PY_VERSION_HEX >= 0x03030000 if (cause) { #else if (cause && cause != Py_None) { #endif PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(tmp_type, tmp_value, tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = PyThreadState_GET(); PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif #if !CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); } #endif static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } static CYTHON_INLINE int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); } static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (none_allowed && obj == Py_None) return 1; else if (exact) { if (likely(Py_TYPE(obj) == type)) return 1; #if PY_MAJOR_VERSION == 2 else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(PyObject_TypeCheck(obj, type))) return 1; } __Pyx_RaiseArgumentTypeInvalid(name, obj, type); return 0; } static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_Clear(); else return NULL; } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { Py_ssize_t length; if (unlikely((start < 0) | (stop < 0))) { length = strlen(cstring); if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; } length = stop - start; if (unlikely(length <= 0)) return PyUnicode_FromUnicode(NULL, 0); cstring += start; if (decode_func) { return decode_func(cstring, length, errors); } else { return PyUnicode_Decode(cstring, length, encoding, errors); } } static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = (start + end) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; py_code = __pyx_find_code_object(c_line ? c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? c_line : py_line, py_code); } py_frame = PyFrame_New( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; py_frame->f_lineno = py_line; PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_VERSION_HEX < 0x03030000 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(1); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); #endif if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_VERSION_HEX < 0x03030000 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(int) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value) \ { \ func_type value = func_value; \ if (sizeof(target_type) < sizeof(func_type)) { \ if (unlikely(value != (func_type) (target_type) value)) { \ func_type zero = 0; \ if (is_unsigned && unlikely(value < zero)) \ goto raise_neg_overflow; \ else \ goto raise_overflow; \ } \ } \ return (target_type) value; \ } #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #endif #endif static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(int) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyLong_AsLong(x)) } else if (sizeof(int) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(int, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value) { const fuse_ino_t neg_one = (fuse_ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(fuse_ino_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(fuse_ino_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fuse_ino_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(fuse_ino_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) { const unsigned long neg_one = (unsigned long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(unsigned long) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(unsigned long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned long) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(unsigned long), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(long) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value) { const time_t neg_one = (time_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(time_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(time_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(time_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(time_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(time_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(time_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value) { const mode_t neg_one = (mode_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(mode_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(mode_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(mode_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(mode_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(mode_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(mode_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value) { const uid_t neg_one = (uid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uid_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value) { const gid_t neg_one = (gid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(gid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(gid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(gid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(gid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(gid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(gid_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value) { const off_t neg_one = (off_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(off_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(off_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(off_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(off_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(off_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(off_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value) { const dev_t neg_one = (dev_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(dev_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(dev_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(dev_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(dev_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(dev_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(dev_t), little, !is_unsigned); } } static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) { const uint64_t neg_one = (uint64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uint64_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint64_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(uint64_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(uint64_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(uint64_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long, PyLong_AsLong(x)) } else if (sizeof(uint64_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uint64_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uint64_t) -1; } } else { uint64_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (uint64_t) -1; val = __Pyx_PyInt_As_uint64_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint64_t"); return (uint64_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint64_t"); return (uint64_t) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) { const uint64_t neg_one = (uint64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint64_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uint64_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uint64_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint64_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uint64_t), little, !is_unsigned); } } static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { const size_t neg_one = (size_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(size_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (size_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(size_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(size_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(size_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyLong_AsLong(x)) } else if (sizeof(size_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(size_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else size_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (size_t) -1; } } else { size_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (size_t) -1; val = __Pyx_PyInt_As_size_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to size_t"); return (size_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to size_t"); return (size_t) -1; } static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *x) { const off_t neg_one = (off_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(off_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(off_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (off_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(off_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(off_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(off_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(off_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(off_t, long, PyLong_AsLong(x)) } else if (sizeof(off_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(off_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else off_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (off_t) -1; } } else { off_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (off_t) -1; val = __Pyx_PyInt_As_off_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to off_t"); return (off_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to off_t"); return (off_t) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value) { const uint32_t neg_one = (uint32_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint32_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint32_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uint32_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uint32_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint32_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uint32_t), little, !is_unsigned); } } static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *x) { const fuse_ino_t neg_one = (fuse_ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fuse_ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fuse_ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fuse_ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, PyLong_AsLong(x)) } else if (sizeof(fuse_ino_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fuse_ino_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fuse_ino_t) -1; } } else { fuse_ino_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fuse_ino_t) -1; val = __Pyx_PyInt_As_fuse_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fuse_ino_t"); return (fuse_ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fuse_ino_t"); return (fuse_ino_t) -1; } static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) { const unsigned long neg_one = (unsigned long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(unsigned long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(unsigned long) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(unsigned long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyLong_AsLong(x)) } else if (sizeof(unsigned long) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned long val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned long) -1; } } else { unsigned long val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (unsigned long) -1; val = __Pyx_PyInt_As_unsigned_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned long"); return (unsigned long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned long"); return (unsigned long) -1; } static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *x) { const ino_t neg_one = (ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(ino_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(ino_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(ino_t, long, PyLong_AsLong(x)) } else if (sizeof(ino_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(ino_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else ino_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (ino_t) -1; } } else { ino_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (ino_t) -1; val = __Pyx_PyInt_As_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to ino_t"); return (ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to ino_t"); return (ino_t) -1; } static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *x) { const mode_t neg_one = (mode_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(mode_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(mode_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (mode_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(mode_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(mode_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(mode_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(mode_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(mode_t, long, PyLong_AsLong(x)) } else if (sizeof(mode_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(mode_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else mode_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (mode_t) -1; } } else { mode_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (mode_t) -1; val = __Pyx_PyInt_As_mode_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to mode_t"); return (mode_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to mode_t"); return (mode_t) -1; } static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *x) { const nlink_t neg_one = (nlink_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(nlink_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (nlink_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(nlink_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(nlink_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(nlink_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(nlink_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long, PyLong_AsLong(x)) } else if (sizeof(nlink_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else nlink_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (nlink_t) -1; } } else { nlink_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (nlink_t) -1; val = __Pyx_PyInt_As_nlink_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to nlink_t"); return (nlink_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to nlink_t"); return (nlink_t) -1; } static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *x) { const uid_t neg_one = (uid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(uid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(uid_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(uid_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(uid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(uid_t, long, PyLong_AsLong(x)) } else if (sizeof(uid_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(uid_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uid_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uid_t) -1; } } else { uid_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (uid_t) -1; val = __Pyx_PyInt_As_uid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uid_t"); return (uid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uid_t"); return (uid_t) -1; } static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *x) { const gid_t neg_one = (gid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(gid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(gid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (gid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(gid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(gid_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(gid_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(gid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(gid_t, long, PyLong_AsLong(x)) } else if (sizeof(gid_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(gid_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else gid_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (gid_t) -1; } } else { gid_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (gid_t) -1; val = __Pyx_PyInt_As_gid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to gid_t"); return (gid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to gid_t"); return (gid_t) -1; } static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *x) { const dev_t neg_one = (dev_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(dev_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(dev_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (dev_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(dev_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(dev_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(dev_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(dev_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(dev_t, long, PyLong_AsLong(x)) } else if (sizeof(dev_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(dev_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else dev_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (dev_t) -1; } } else { dev_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (dev_t) -1; val = __Pyx_PyInt_As_dev_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to dev_t"); return (dev_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to dev_t"); return (dev_t) -1; } static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *x) { const blksize_t neg_one = (blksize_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blksize_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blksize_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(blksize_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(blksize_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(blksize_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(blksize_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long, PyLong_AsLong(x)) } else if (sizeof(blksize_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blksize_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blksize_t) -1; } } else { blksize_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (blksize_t) -1; val = __Pyx_PyInt_As_blksize_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blksize_t"); return (blksize_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blksize_t"); return (blksize_t) -1; } static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *x) { const blkcnt_t neg_one = (blkcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(blkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(blkcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(blkcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(blkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(blkcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blkcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blkcnt_t) -1; } } else { blkcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (blkcnt_t) -1; val = __Pyx_PyInt_As_blkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blkcnt_t"); return (blkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blkcnt_t"); return (blkcnt_t) -1; } static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) { const time_t neg_one = (time_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(time_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(time_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (time_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(time_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(time_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(time_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(time_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(time_t, long, PyLong_AsLong(x)) } else if (sizeof(time_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(time_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else time_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (time_t) -1; } } else { time_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (time_t) -1; val = __Pyx_PyInt_As_time_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to time_t"); return (time_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to time_t"); return (time_t) -1; } static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(long) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyLong_AsLong(x)) } else if (sizeof(long) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(long, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *x) { const fsblkcnt_t neg_one = (fsblkcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsblkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsblkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fsblkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fsblkcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fsblkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(fsblkcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsblkcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsblkcnt_t) -1; } } else { fsblkcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fsblkcnt_t) -1; val = __Pyx_PyInt_As_fsblkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsblkcnt_t"); return (fsblkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsblkcnt_t"); return (fsblkcnt_t) -1; } static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *x) { const fsfilcnt_t neg_one = (fsfilcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsfilcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsfilcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fsfilcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fsfilcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fsfilcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(fsfilcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsfilcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsfilcnt_t) -1; } } else { fsfilcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fsfilcnt_t) -1; val = __Pyx_PyInt_As_fsfilcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsfilcnt_t"); return (fsfilcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsfilcnt_t"); return (fsfilcnt_t) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value) { const pid_t neg_one = (pid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(pid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(pid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(pid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(pid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(pid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(pid_t), little, !is_unsigned); } } static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { #if PY_VERSION_HEX < 0x03030000 char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; #else if (__Pyx_PyUnicode_READY(o) == -1) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (PyUnicode_IS_ASCII(o)) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif #endif } else #endif #if !CYTHON_COMPILING_IN_PYPY if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { PyNumberMethods *m; const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(x) || PyLong_Check(x)) #else if (PyLong_Check(x)) #endif return Py_INCREF(x), x; m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = PyNumber_Int(x); } else if (m && m->nb_long) { name = "long"; res = PyNumber_Long(x); } #else if (m && m->nb_int) { name = "int"; res = PyNumber_Long(x); } #endif if (res) { #if PY_MAJOR_VERSION < 3 if (!PyInt_Check(res) && !PyLong_Check(res)) { #else if (!PyLong_Check(res)) { #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", name, name, Py_TYPE(res)->tp_name); Py_DECREF(res); return NULL; } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) return PyInt_AS_LONG(b); #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(b)) { case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0]; case 0: return 0; case 1: return ((PyLongObject*)b)->ob_digit[0]; } #endif #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ llfuse-0.41.1/src/llfuse/capi_freebsd.c0000664000175000017500000521773412566230167021441 0ustar nikrationikratio00000000000000/* Generated by Cython 0.21.1 */ #define PY_SSIZE_T_CLEAN #ifndef CYTHON_USE_PYLONG_INTERNALS #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 0 #else #include "pyconfig.h" #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 1 #else #define CYTHON_USE_PYLONG_INTERNALS 0 #endif #endif #endif #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else #define CYTHON_ABI "0_21_1" #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #if PY_MAJOR_VERSION >= 3 #define Py_TPFLAGS_CHECKTYPES 0 #define Py_TPFLAGS_HAVE_INDEX 0 #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #if PY_VERSION_HEX < 0x030400a1 && !defined(Py_TPFLAGS_HAVE_FINALIZE) #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #else #define CYTHON_PEP393_ENABLED 0 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #define __Pyx_PyFrozenSet_Size(s) PyObject_Size(s) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #define __Pyx_PyFrozenSet_Size(s) PySet_Size(s) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #ifndef CYTHON_INLINE #if defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is a quiet NaN. */ float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #ifdef __cplusplus template void __Pyx_call_destructor(T* x) { x->~T(); } #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #define __PYX_HAVE__llfuse__capi #define __PYX_HAVE_API__llfuse__capi #include "fuse_opt.h" #include "stdint.h" #include "sys/types.h" #include "sys/stat.h" #include "sys/statvfs.h" #include "string.h" #include "stdlib.h" #include "fuse_lowlevel.h" #include "errno.h" #include "dirent.h" #include "sys/extattr.h" #include "unistd.h" #include "signal.h" #include "sys/time.h" #include "lock.c" #include "time.c" #include "version.c" #ifdef _OPENMP #include #endif /* _OPENMP */ #ifdef PYREX_WITHOUT_ASSERTIONS #define CYTHON_WITHOUT_ASSERTIONS #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ (sizeof(type) < sizeof(Py_ssize_t)) || \ (sizeof(type) > sizeof(Py_ssize_t) && \ likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX) && \ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ v == (type)PY_SSIZE_T_MIN))) || \ (sizeof(type) == sizeof(Py_ssize_t) && \ (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromUString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((const char*)s) #if PY_MAJOR_VERSION < 3 static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #else #define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen #endif #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) #define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_COMPILING_IN_CPYTHON #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static PyObject *__pyx_m; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "llfuse/handlers.pxi", "llfuse/misc.pxi", "llfuse/fuse_api.pxi", "llfuse/capi.pyx", }; /*--- Type declarations ---*/ struct __pyx_obj_6llfuse_4capi_Lock; struct __pyx_obj_6llfuse_4capi_NoLockManager; /* "src/llfuse/misc.pxi":185 * raise * * cdef class Lock: # <<<<<<<<<<<<<< * ''' * This is the class of lock itself as well as a context manager to */ struct __pyx_obj_6llfuse_4capi_Lock { PyObject_HEAD }; /* "src/llfuse/misc.pxi":278 * * * cdef class NoLockManager: # <<<<<<<<<<<<<< * '''Context manager to execute code while the global lock is released''' * */ struct __pyx_obj_6llfuse_4capi_NoLockManager { PyObject_HEAD }; #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil) \ if (acquire_gil) { \ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ PyGILState_Release(__pyx_gilstate_save); \ } else { \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil) \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext() \ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_XDECREF(tmp); \ } while (0) #define __Pyx_DECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_DECREF(tmp); \ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name); #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) { PyObject *res; PyTypeObject *tp = Py_TYPE(obj); #if PY_MAJOR_VERSION < 3 if (unlikely(PyInstance_Check(obj))) return __Pyx_PyObject_GetAttrStr(obj, attr_name); #endif res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #else #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback); static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); static CYTHON_INLINE int __Pyx_IterFinish(void); static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyString_Join __Pyx_PyBytes_Join #define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) #else #define __Pyx_PyString_Join PyUnicode_Join #define __Pyx_PyBaseString_Join PyUnicode_Join #endif #if CYTHON_COMPILING_IN_CPYTHON #if PY_MAJOR_VERSION < 3 #define __Pyx_PyBytes_Join _PyString_Join #else #define __Pyx_PyBytes_Join _PyBytes_Join #endif #else static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); #endif static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ const char* function_name); static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact); #include static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) : \ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) : \ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); typedef struct { int code_line; PyCodeObject* code_object; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value); static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *); static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *); static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *); static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *); static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *); static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *); static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *); static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *); static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *); static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *); static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *); static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *); static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *); static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value); static int __Pyx_check_binary_version(void); static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'fuse_opt' */ /* Module declarations from 'libc.stdint' */ /* Module declarations from 'fuse_common' */ /* Module declarations from 'libc.sys.types' */ /* Module declarations from 'libc.sys.stat' */ /* Module declarations from 'libc.sys.statvfs' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdlib' */ /* Module declarations from 'fuse_lowlevel' */ /* Module declarations from 'libc' */ /* Module declarations from 'libc.errno' */ /* Module declarations from 'libc.dirent' */ /* Module declarations from 'libc.xattr' */ /* Module declarations from 'posix.types' */ /* Module declarations from 'posix.unistd' */ /* Module declarations from 'posix.signal' */ /* Module declarations from 'posix.time' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.version' */ /* Module declarations from 'llfuse.capi' */ static PyTypeObject *__pyx_ptype_6llfuse_4capi_Lock = 0; static PyTypeObject *__pyx_ptype_6llfuse_4capi_NoLockManager = 0; static PyObject *__pyx_v_6llfuse_4capi_operations = 0; static PyObject *__pyx_v_6llfuse_4capi_mountpoint_b = 0; static struct fuse_session *__pyx_v_6llfuse_4capi_session; static struct fuse_chan *__pyx_v_6llfuse_4capi_channel; static struct fuse_lowlevel_ops __pyx_v_6llfuse_4capi_fuse_ops; static PyObject *__pyx_v_6llfuse_4capi_exc_info = 0; static void __pyx_f_6llfuse_4capi_fuse_init(void *, struct fuse_conn_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_destroy(void *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_lookup(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_forget(fuse_req_t, fuse_ino_t, unsigned long); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_getattr(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_setattr(fuse_req_t, fuse_ino_t, struct stat *, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_readlink(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_mknod(fuse_req_t, fuse_ino_t, const char *, mode_t, dev_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_mkdir(fuse_req_t, fuse_ino_t, const char *, mode_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_unlink(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_rmdir(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_symlink(fuse_req_t, const char *, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_rename(fuse_req_t, fuse_ino_t, const char *, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_link(fuse_req_t, fuse_ino_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_open(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_read(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_write(fuse_req_t, fuse_ino_t, const char *, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_flush(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_release(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_fsync(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_opendir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_readdir(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_releasedir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_fsyncdir(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_statfs(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_setxattr(fuse_req_t, fuse_ino_t, const char *, const char *, size_t, int); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_getxattr(fuse_req_t, fuse_ino_t, const char *, size_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_listxattr(fuse_req_t, fuse_ino_t, size_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_removexattr(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_access(fuse_req_t, fuse_ino_t, int); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_create(fuse_req_t, fuse_ino_t, const char *, mode_t, struct fuse_file_info *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_entry_param(PyObject *, struct fuse_entry_param *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_c_stat(PyObject *, struct stat *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_statvfs(PyObject *, struct statvfs *); /*proto*/ static int __pyx_f_6llfuse_4capi_handle_exc(char *, PyObject *, fuse_req_t); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_get_request_context(fuse_req_t); /*proto*/ static void __pyx_f_6llfuse_4capi_init_fuse_ops(void); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_make_fuse_args(PyObject *, struct fuse_args *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_str2bytes(PyObject *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_bytes2str(PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "llfuse.capi" int __pyx_module_is_main_llfuse__capi = 0; /* Implementation of 'llfuse.capi' */ static PyObject *__pyx_builtin_BaseException; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_OSError; static PyObject *__pyx_builtin_ValueError; static int __pyx_pf_6llfuse_4capi_4Lock___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_2acquire(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_timeout); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_4release(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_6yield_(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_count); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_8__enter__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_10__exit__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb); /* proto */ static int __pyx_pf_6llfuse_4capi_13NoLockManager___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_a); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi__notify_loop(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_2listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_6getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, int __pyx_v_size_guess, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_8init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_args); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_10main(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_single); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_12close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_14invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode, PyObject *__pyx_v_attr_only); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_16invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode_p, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_18get_ino_t_bits(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_20get_off_t_bits(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_tp_new_6llfuse_4capi_Lock(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6llfuse_4capi_NoLockManager(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static char __pyx_k_o[] = "-o"; static char __pyx_k_t[] = "t"; static char __pyx_k_os[] = "os"; static char __pyx_k__28[] = "\000"; static char __pyx_k__49[] = "."; static char __pyx_k__50[] = ".."; static char __pyx_k_buf[] = "buf"; static char __pyx_k_ent[] = "ent"; static char __pyx_k_fse[] = "fse"; static char __pyx_k_get[] = "get"; static char __pyx_k_gid[] = "gid"; static char __pyx_k_ino[] = "ino"; static char __pyx_k_len[] = "len_"; static char __pyx_k_log[] = "log"; static char __pyx_k_ops[] = "ops"; static char __pyx_k_pid[] = "pid"; static char __pyx_k_put[] = "put"; static char __pyx_k_req[] = "req"; static char __pyx_k_res[] = "res"; static char __pyx_k_ret[] = "ret"; static char __pyx_k_sys[] = "sys"; static char __pyx_k_tmp[] = "tmp"; static char __pyx_k_uid[] = "uid"; static char __pyx_k_args[] = "args"; static char __pyx_k_dirp[] = "dirp"; static char __pyx_k_exit[] = "__exit__"; static char __pyx_k_init[] = "init"; static char __pyx_k_join[] = "join"; static char __pyx_k_link[] = "link"; static char __pyx_k_lock[] = "lock"; static char __pyx_k_main[] = "__main__"; static char __pyx_k_name[] = "name"; static char __pyx_k_open[] = "open"; static char __pyx_k_path[] = "path"; static char __pyx_k_read[] = "read"; static char __pyx_k_test[] = "__test__"; static char __pyx_k_user[] = "user"; static char __pyx_k_Queue[] = "Queue"; static char __pyx_k_block[] = "block"; static char __pyx_k_close[] = "close"; static char __pyx_k_cname[] = "cname"; static char __pyx_k_count[] = "count"; static char __pyx_k_cpath[] = "cpath"; static char __pyx_k_debug[] = "debug"; static char __pyx_k_enter[] = "__enter__"; static char __pyx_k_errno[] = "errno"; static char __pyx_k_error[] = "error"; static char __pyx_k_flush[] = "flush"; static char __pyx_k_fsync[] = "fsync"; static char __pyx_k_inode[] = "inode"; static char __pyx_k_mkdir[] = "mkdir"; static char __pyx_k_mknod[] = "mknod"; static char __pyx_k_names[] = "names"; static char __pyx_k_queue[] = "queue"; static char __pyx_k_range[] = "range"; static char __pyx_k_rmdir[] = "rmdir"; static char __pyx_k_start[] = "start"; static char __pyx_k_str_t[] = "str_t"; static char __pyx_k_umask[] = "umask"; static char __pyx_k_value[] = "value"; static char __pyx_k_write[] = "write"; static char __pyx_k_Thread[] = "Thread"; static char __pyx_k_access[] = "access"; static char __pyx_k_create[] = "create"; static char __pyx_k_cvalue[] = "cvalue"; static char __pyx_k_daemon[] = "daemon"; static char __pyx_k_decode[] = "decode"; static char __pyx_k_encode[] = "encode"; static char __pyx_k_exc_tb[] = "exc_tb"; static char __pyx_k_f_args[] = "f_args"; static char __pyx_k_forget[] = "forget"; static char __pyx_k_import[] = "__import__"; static char __pyx_k_llfuse[] = "llfuse"; static char __pyx_k_lookup[] = "lookup"; static char __pyx_k_main_2[] = "main"; static char __pyx_k_name_b[] = "name_b"; static char __pyx_k_path_b[] = "path_b"; static char __pyx_k_rename[] = "rename"; static char __pyx_k_single[] = "single"; static char __pyx_k_st_gid[] = "st_gid"; static char __pyx_k_st_ino[] = "st_ino"; static char __pyx_k_st_uid[] = "st_uid"; static char __pyx_k_statfs[] = "statfs"; static char __pyx_k_system[] = "system"; static char __pyx_k_target[] = "target"; static char __pyx_k_unlink[] = "unlink"; static char __pyx_k_ENOATTR[] = "ENOATTR"; static char __pyx_k_OSError[] = "OSError"; static char __pyx_k_abspath[] = "abspath"; static char __pyx_k_acquire[] = "acquire"; static char __pyx_k_bufsize[] = "bufsize"; static char __pyx_k_destroy[] = "destroy"; static char __pyx_k_exc_val[] = "exc_val"; static char __pyx_k_f_bfree[] = "f_bfree"; static char __pyx_k_f_bsize[] = "f_bsize"; static char __pyx_k_f_ffree[] = "f_ffree"; static char __pyx_k_f_files[] = "f_files"; static char __pyx_k_getattr[] = "getattr"; static char __pyx_k_inode_p[] = "inode_p"; static char __pyx_k_listdir[] = "listdir"; static char __pyx_k_logging[] = "logging"; static char __pyx_k_maxsize[] = "maxsize"; static char __pyx_k_opendir[] = "opendir"; static char __pyx_k_os_path[] = "os.path"; static char __pyx_k_readdir[] = "readdir"; static char __pyx_k_release[] = "release"; static char __pyx_k_setattr[] = "setattr"; static char __pyx_k_st_mode[] = "st_mode"; static char __pyx_k_st_rdev[] = "st_rdev"; static char __pyx_k_st_size[] = "st_size"; static char __pyx_k_symlink[] = "symlink"; static char __pyx_k_timeout[] = "timeout"; static char __pyx_k_unmount[] = "unmount"; static char __pyx_k_version[] = "__version__"; static char __pyx_k_exc_info[] = "exc_info"; static char __pyx_k_exc_type[] = "exc_type"; static char __pyx_k_f_bavail[] = "f_bavail"; static char __pyx_k_f_blocks[] = "f_blocks"; static char __pyx_k_f_favail[] = "f_favail"; static char __pyx_k_f_frsize[] = "f_frsize"; static char __pyx_k_fsyncdir[] = "fsyncdir"; static char __pyx_k_getxattr[] = "getxattr"; static char __pyx_k_readlink[] = "readlink"; static char __pyx_k_setxattr[] = "setxattr"; static char __pyx_k_st_atime[] = "st_atime"; static char __pyx_k_st_ctime[] = "st_ctime"; static char __pyx_k_st_mtime[] = "st_mtime"; static char __pyx_k_st_nlink[] = "st_nlink"; static char __pyx_k_strerror[] = "strerror"; static char __pyx_k_us_ascii[] = "us-ascii"; static char __pyx_k_FUSEError[] = "FUSEError"; static char __pyx_k_TypeError[] = "TypeError"; static char __pyx_k_attr_only[] = "attr_only"; static char __pyx_k_enumerate[] = "enumerate"; static char __pyx_k_exception[] = "exception"; static char __pyx_k_getLogger[] = "getLogger"; static char __pyx_k_listxattr[] = "listxattr"; static char __pyx_k_namespace[] = "namespace"; static char __pyx_k_st_blocks[] = "st_blocks"; static char __pyx_k_threading[] = "threading"; static char __pyx_k_Operations[] = "Operations"; static char __pyx_k_ROOT_INODE[] = "ROOT_INODE"; static char __pyx_k_ValueError[] = "ValueError"; static char __pyx_k_cnamespace[] = "cnamespace"; static char __pyx_k_generation[] = "generation"; static char __pyx_k_mountpoint[] = "mountpoint"; static char __pyx_k_namedtuple[] = "namedtuple"; static char __pyx_k_releasedir[] = "releasedir"; static char __pyx_k_size_guess[] = "size_guess"; static char __pyx_k_st_blksize[] = "st_blksize"; static char __pyx_k_stacktrace[] = "stacktrace"; static char __pyx_k_collections[] = "collections"; static char __pyx_k_llfuse_capi[] = "llfuse.capi"; static char __pyx_k_notify_loop[] = "_notify_loop"; static char __pyx_k_removexattr[] = "removexattr"; static char __pyx_k_st_atime_ns[] = "st_atime_ns"; static char __pyx_k_st_ctime_ns[] = "st_ctime_ns"; static char __pyx_k_st_mtime_ns[] = "st_mtime_ns"; static char __pyx_k_RuntimeError[] = "RuntimeError"; static char __pyx_k_attr_timeout[] = "attr_timeout"; static char __pyx_k_llfuse_pyapi[] = "llfuse.pyapi"; static char __pyx_k_notify_queue[] = "_notify_queue"; static char __pyx_k_BaseException[] = "BaseException"; static char __pyx_k_Python_LLFUSE[] = "Python-LLFUSE"; static char __pyx_k_entry_timeout[] = "entry_timeout"; static char __pyx_k_lock_released[] = "lock_released"; static char __pyx_k_RequestContext[] = "RequestContext"; static char __pyx_k_get_ino_t_bits[] = "get_ino_t_bits"; static char __pyx_k_get_off_t_bits[] = "get_off_t_bits"; static char __pyx_k_with_traceback[] = "with_traceback"; static char __pyx_k_EntryAttributes[] = "EntryAttributes"; static char __pyx_k_fuse_stacktrace[] = "fuse_stacktrace"; static char __pyx_k_inval_entry_req[] = "inval_entry_req"; static char __pyx_k_inval_inode_req[] = "inval_inode_req"; static char __pyx_k_surrogateescape[] = "surrogateescape"; static char __pyx_k_invalidate_entry[] = "invalidate_entry"; static char __pyx_k_invalidate_inode[] = "invalidate_inode"; static char __pyx_k_fuse_mount_failed[] = "fuse_mount failed"; static char __pyx_k_Calling_fuse_mount[] = "Calling fuse_mount"; static char __pyx_k_Initializing_llfuse[] = "Initializing llfuse"; static char __pyx_k_Calling_fuse_unmount[] = "Calling fuse_unmount"; static char __pyx_k_Exception_after_kill[] = "Exception after kill:"; static char __pyx_k_Lock_not_initialized[] = "Lock not initialized"; static char __pyx_k_getfilesystemencoding[] = "getfilesystemencoding"; static char __pyx_k_Weird_request_received_r[] = "Weird request received: %r"; static char __pyx_k_fuse_lowlevel_new_failed[] = "fuse_lowlevel_new() failed"; static char __pyx_k_fuse_session_loop_failed[] = "fuse_session_loop failed"; static char __pyx_k_Calling_fuse_lowlevel_new[] = "Calling fuse_lowlevel_new"; static char __pyx_k_Calling_fuse_session_loop[] = "Calling fuse_session_loop"; static char __pyx_k_fuse_session_loop_mt_failed[] = "fuse_session_loop_mt() failed"; static char __pyx_k_Calling_fuse_session_destroy[] = "Calling fuse_session_destroy"; static char __pyx_k_Calling_fuse_session_loop_mt[] = "Calling fuse_session_loop_mt"; static char __pyx_k_Calling_fuse_session_add_chan[] = "Calling fuse_session_add_chan"; static char __pyx_k_Need_to_call_init_before_main[] = "Need to call init() before main()"; static char __pyx_k_Other_thread_didn_t_take_lock[] = "Other thread didn't take lock"; static char __pyx_k_You_should_not_instantiate_this[] = "You should not instantiate this class, use the provided instance instead."; static char __pyx_k_capi_pxy_Copyright_2013_Nikolau[] = "\ncapi.pxy\n\nCopyright \302\251 2013 Nikolaus Rath \n\nThis file is part of Python-LLFUSE. This work may be distributed under\nthe terms of the GNU LGPL.\n"; static char __pyx_k_fuse_getattr_fuse_reply__failed[] = "fuse_getattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_opendir_fuse_reply__failed[] = "fuse_opendir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_readdir_fuse_reply__failed[] = "fuse_readdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_release_fuse_reply__failed[] = "fuse_release(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_set_signal_handlers_failed[] = "fuse_set_signal_handlers() failed"; static char __pyx_k_fuse_setattr_fuse_reply__failed[] = "fuse_setattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_symlink_fuse_reply__failed[] = "fuse_symlink(): fuse_reply_* failed with %s"; static char __pyx_k_home_nikratio_in_progress_pytho[] = "/home/nikratio/in-progress/python-llfuse/src/llfuse/misc.pxi"; static char __pyx_k_mountpoint__argument_must_be_of[] = "*mountpoint_* argument must be of type str"; static char __pyx_k_name_argument_must_be_of_type_s[] = "*name* argument must be of type str"; static char __pyx_k_namespace_parameter_must_be_sys[] = "*namespace* parameter must be \"system\" or \"user\", not %s"; static char __pyx_k_path_argument_must_be_of_type_s[] = "*path* argument must be of type str"; static char __pyx_k_Calling_fuse_remove_signal_handl[] = "Calling fuse_remove_signal_handlers"; static char __pyx_k_Calling_fuse_session_remove_chan[] = "Calling fuse_session_remove_chan"; static char __pyx_k_Calling_fuse_set_signal_handlers[] = "Calling fuse_set_signal_handlers"; static char __pyx_k_Global_lock_cannot_be_acquired_m[] = "Global lock cannot be acquired more than once"; static char __pyx_k_Lock_can_only_be_released_by_the[] = "Lock can only be released by the holding thread"; static char __pyx_k_Lock_still_taken_after_receiving[] = "Lock still taken after receiving unlock notification"; static char __pyx_k_Terminated_main_loop_because_req[] = "Terminated main loop because request handler raised exception, re-raising.."; static char __pyx_k_fuse_access_fuse_reply__failed_w[] = "fuse_access(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_create_fuse_reply__failed_w[] = "fuse_create(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_flush_fuse_reply__failed_wi[] = "fuse_flush(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_fsync_fuse_reply__failed_wi[] = "fuse_fsync(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_fsyncdir_fuse_reply__failed[] = "fuse_fsyncdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_getxattr_fuse_reply__failed[] = "fuse_getxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_link_fuse_reply__failed_wit[] = "fuse_link(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_listxattr_fuse_reply__faile[] = "fuse_listxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_lookup_fuse_reply__failed_w[] = "fuse_lookup(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_mkdir_fuse_reply__failed_wi[] = "fuse_mkdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_mknod_fuse_reply__failed_wi[] = "fuse_mknod(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_options_must_be_of_type_str[] = "fuse options must be of type str"; static char __pyx_k_fuse_read_fuse_reply__failed_wit[] = "fuse_read(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_readlink_fuse_reply__failed[] = "fuse_readlink(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_releasedir_fuse_reply__fail[] = "fuse_releasedir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_removexattr_fuse_reply__fai[] = "fuse_removexattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_rename_fuse_reply__failed_w[] = "fuse_rename(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_rmdir_fuse_reply__failed_wi[] = "fuse_rmdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_setattr_clock_gettime_CLOCK[] = "fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s"; static char __pyx_k_fuse_setxattr_fuse_reply__failed[] = "fuse_setxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_statfs_fuse_reply__failed_w[] = "fuse_statfs(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_unlink_fuse_reply__failed_w[] = "fuse_unlink(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_write_fuse_reply_err_d_fail[] = "fuse_write(): fuse_reply_err(%d) failed with %s"; static char __pyx_k_fuse_write_fuse_reply_err_failed[] = "fuse_write(): fuse_reply_err failed with %s after exception"; static char __pyx_k_fuse_write_fuse_reply_write_fail[] = "fuse_write(): fuse_reply_write failed with %s"; static char __pyx_k_handler_raised_exception_sending[] = "handler raised exception, sending SIGTERM to self."; static char __pyx_k_home_nikratio_in_progress_pytho_2[] = "/home/nikratio/in-progress/python-llfuse/src/llfuse/fuse_api.pxi"; static PyObject *__pyx_n_s_BaseException; static PyObject *__pyx_kp_u_Calling_fuse_lowlevel_new; static PyObject *__pyx_kp_u_Calling_fuse_mount; static PyObject *__pyx_kp_u_Calling_fuse_remove_signal_handl; static PyObject *__pyx_kp_u_Calling_fuse_session_add_chan; static PyObject *__pyx_kp_u_Calling_fuse_session_destroy; static PyObject *__pyx_kp_u_Calling_fuse_session_loop; static PyObject *__pyx_kp_u_Calling_fuse_session_loop_mt; static PyObject *__pyx_kp_u_Calling_fuse_session_remove_chan; static PyObject *__pyx_kp_u_Calling_fuse_set_signal_handlers; static PyObject *__pyx_kp_u_Calling_fuse_unmount; static PyObject *__pyx_n_s_ENOATTR; static PyObject *__pyx_n_s_EntryAttributes; static PyObject *__pyx_kp_u_Exception_after_kill; static PyObject *__pyx_n_s_FUSEError; static PyObject *__pyx_kp_u_Global_lock_cannot_be_acquired_m; static PyObject *__pyx_kp_u_Initializing_llfuse; static PyObject *__pyx_kp_u_Lock_can_only_be_released_by_the; static PyObject *__pyx_kp_u_Lock_not_initialized; static PyObject *__pyx_kp_u_Lock_still_taken_after_receiving; static PyObject *__pyx_kp_u_Need_to_call_init_before_main; static PyObject *__pyx_n_s_OSError; static PyObject *__pyx_n_s_Operations; static PyObject *__pyx_kp_u_Other_thread_didn_t_take_lock; static PyObject *__pyx_kp_b_Python_LLFUSE; static PyObject *__pyx_n_s_Queue; static PyObject *__pyx_n_s_ROOT_INODE; static PyObject *__pyx_n_s_RequestContext; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_kp_u_Terminated_main_loop_because_req; static PyObject *__pyx_n_s_Thread; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_kp_u_Weird_request_received_r; static PyObject *__pyx_kp_u_You_should_not_instantiate_this; static PyObject *__pyx_kp_b__28; static PyObject *__pyx_n_s_abspath; static PyObject *__pyx_n_s_access; static PyObject *__pyx_n_s_acquire; static PyObject *__pyx_n_s_args; static PyObject *__pyx_n_s_attr_only; static PyObject *__pyx_n_u_attr_only; static PyObject *__pyx_n_s_attr_timeout; static PyObject *__pyx_n_s_block; static PyObject *__pyx_n_s_buf; static PyObject *__pyx_n_s_bufsize; static PyObject *__pyx_n_s_close; static PyObject *__pyx_n_s_cname; static PyObject *__pyx_n_s_cnamespace; static PyObject *__pyx_n_s_collections; static PyObject *__pyx_n_s_count; static PyObject *__pyx_n_s_cpath; static PyObject *__pyx_n_s_create; static PyObject *__pyx_n_s_cvalue; static PyObject *__pyx_n_s_daemon; static PyObject *__pyx_n_s_debug; static PyObject *__pyx_n_s_decode; static PyObject *__pyx_n_s_destroy; static PyObject *__pyx_n_s_dirp; static PyObject *__pyx_n_s_encode; static PyObject *__pyx_n_s_ent; static PyObject *__pyx_n_s_enter; static PyObject *__pyx_n_s_entry_timeout; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_errno; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_exc_info; static PyObject *__pyx_n_s_exc_tb; static PyObject *__pyx_n_s_exc_type; static PyObject *__pyx_n_s_exc_val; static PyObject *__pyx_n_s_exception; static PyObject *__pyx_n_s_exit; static PyObject *__pyx_n_s_f_args; static PyObject *__pyx_n_s_f_bavail; static PyObject *__pyx_n_s_f_bfree; static PyObject *__pyx_n_s_f_blocks; static PyObject *__pyx_n_s_f_bsize; static PyObject *__pyx_n_s_f_favail; static PyObject *__pyx_n_s_f_ffree; static PyObject *__pyx_n_s_f_files; static PyObject *__pyx_n_s_f_frsize; static PyObject *__pyx_n_s_flush; static PyObject *__pyx_n_s_forget; static PyObject *__pyx_n_s_fse; static PyObject *__pyx_n_s_fsync; static PyObject *__pyx_n_s_fsyncdir; static PyObject *__pyx_kp_u_fuse_access_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_create_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_flush_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_getattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_getxattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_link_fuse_reply__failed_wit; static PyObject *__pyx_kp_u_fuse_listxattr_fuse_reply__faile; static PyObject *__pyx_kp_u_fuse_lookup_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_lowlevel_new_failed; static PyObject *__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_mount_failed; static PyObject *__pyx_kp_u_fuse_opendir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_options_must_be_of_type_str; static PyObject *__pyx_kp_u_fuse_read_fuse_reply__failed_wit; static PyObject *__pyx_kp_u_fuse_readdir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_readlink_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_release_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_releasedir_fuse_reply__fail; static PyObject *__pyx_kp_u_fuse_removexattr_fuse_reply__fai; static PyObject *__pyx_kp_u_fuse_rename_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_session_loop_failed; static PyObject *__pyx_kp_u_fuse_session_loop_mt_failed; static PyObject *__pyx_kp_u_fuse_set_signal_handlers_failed; static PyObject *__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK; static PyObject *__pyx_kp_u_fuse_setattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_setxattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_statfs_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_symlink_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_unlink_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_err_d_fail; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_err_failed; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_write_fail; static PyObject *__pyx_n_s_generation; static PyObject *__pyx_n_s_get; static PyObject *__pyx_n_s_getLogger; static PyObject *__pyx_n_s_get_ino_t_bits; static PyObject *__pyx_n_s_get_off_t_bits; static PyObject *__pyx_n_s_getattr; static PyObject *__pyx_n_s_getfilesystemencoding; static PyObject *__pyx_n_s_getxattr; static PyObject *__pyx_n_s_gid; static PyObject *__pyx_kp_u_handler_raised_exception_sending; static PyObject *__pyx_kp_s_home_nikratio_in_progress_pytho; static PyObject *__pyx_kp_s_home_nikratio_in_progress_pytho_2; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_s_ino; static PyObject *__pyx_n_s_inode; static PyObject *__pyx_n_u_inode; static PyObject *__pyx_n_s_inode_p; static PyObject *__pyx_n_u_inode_p; static PyObject *__pyx_n_s_inval_entry_req; static PyObject *__pyx_n_u_inval_entry_req; static PyObject *__pyx_n_s_inval_inode_req; static PyObject *__pyx_n_u_inval_inode_req; static PyObject *__pyx_n_s_invalidate_entry; static PyObject *__pyx_n_s_invalidate_inode; static PyObject *__pyx_n_s_join; static PyObject *__pyx_n_s_len; static PyObject *__pyx_n_s_link; static PyObject *__pyx_n_s_listdir; static PyObject *__pyx_n_s_listxattr; static PyObject *__pyx_n_u_llfuse; static PyObject *__pyx_n_s_llfuse_capi; static PyObject *__pyx_n_s_llfuse_pyapi; static PyObject *__pyx_n_s_lock; static PyObject *__pyx_n_s_lock_released; static PyObject *__pyx_n_s_log; static PyObject *__pyx_n_s_logging; static PyObject *__pyx_n_s_lookup; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_main_2; static PyObject *__pyx_n_s_maxsize; static PyObject *__pyx_n_s_mkdir; static PyObject *__pyx_n_s_mknod; static PyObject *__pyx_n_s_mountpoint; static PyObject *__pyx_kp_u_mountpoint__argument_must_be_of; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_u_name; static PyObject *__pyx_kp_u_name_argument_must_be_of_type_s; static PyObject *__pyx_n_s_name_b; static PyObject *__pyx_n_s_namedtuple; static PyObject *__pyx_n_s_names; static PyObject *__pyx_n_s_namespace; static PyObject *__pyx_kp_u_namespace_parameter_must_be_sys; static PyObject *__pyx_n_s_notify_loop; static PyObject *__pyx_n_s_notify_queue; static PyObject *__pyx_kp_b_o; static PyObject *__pyx_n_s_open; static PyObject *__pyx_n_s_opendir; static PyObject *__pyx_n_s_ops; static PyObject *__pyx_n_s_os; static PyObject *__pyx_n_s_os_path; static PyObject *__pyx_n_s_path; static PyObject *__pyx_kp_u_path_argument_must_be_of_type_s; static PyObject *__pyx_n_s_path_b; static PyObject *__pyx_n_s_pid; static PyObject *__pyx_n_s_put; static PyObject *__pyx_n_s_queue; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_read; static PyObject *__pyx_n_s_readdir; static PyObject *__pyx_n_s_readlink; static PyObject *__pyx_n_s_release; static PyObject *__pyx_n_s_releasedir; static PyObject *__pyx_n_s_removexattr; static PyObject *__pyx_n_s_rename; static PyObject *__pyx_n_s_req; static PyObject *__pyx_n_s_res; static PyObject *__pyx_n_s_ret; static PyObject *__pyx_n_s_rmdir; static PyObject *__pyx_n_s_setattr; static PyObject *__pyx_n_s_setxattr; static PyObject *__pyx_n_s_single; static PyObject *__pyx_n_s_size_guess; static PyObject *__pyx_n_s_st_atime; static PyObject *__pyx_n_s_st_atime_ns; static PyObject *__pyx_n_s_st_blksize; static PyObject *__pyx_n_s_st_blocks; static PyObject *__pyx_n_s_st_ctime; static PyObject *__pyx_n_s_st_ctime_ns; static PyObject *__pyx_n_s_st_gid; static PyObject *__pyx_n_s_st_ino; static PyObject *__pyx_n_s_st_mode; static PyObject *__pyx_n_s_st_mtime; static PyObject *__pyx_n_s_st_mtime_ns; static PyObject *__pyx_n_s_st_nlink; static PyObject *__pyx_n_s_st_rdev; static PyObject *__pyx_n_s_st_size; static PyObject *__pyx_n_s_st_uid; static PyObject *__pyx_n_s_stacktrace; static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_statfs; static PyObject *__pyx_n_s_str_t; static PyObject *__pyx_n_s_strerror; static PyObject *__pyx_n_u_surrogateescape; static PyObject *__pyx_n_s_symlink; static PyObject *__pyx_n_s_sys; static PyObject *__pyx_n_u_system; static PyObject *__pyx_n_s_t; static PyObject *__pyx_n_s_target; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_threading; static PyObject *__pyx_n_s_timeout; static PyObject *__pyx_n_s_tmp; static PyObject *__pyx_n_s_uid; static PyObject *__pyx_n_s_umask; static PyObject *__pyx_n_s_unlink; static PyObject *__pyx_n_s_unmount; static PyObject *__pyx_kp_u_us_ascii; static PyObject *__pyx_n_u_user; static PyObject *__pyx_n_s_value; static PyObject *__pyx_n_s_version; static PyObject *__pyx_n_s_with_traceback; static PyObject *__pyx_n_s_write; static PyObject *__pyx_float_1e9; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_5; static PyObject *__pyx_int_1000; static PyObject *__pyx_int_1000000000; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__19; static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__21; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__27; static PyObject *__pyx_tuple__29; static PyObject *__pyx_tuple__30; static PyObject *__pyx_tuple__31; static PyObject *__pyx_tuple__32; static PyObject *__pyx_tuple__33; static PyObject *__pyx_tuple__34; static PyObject *__pyx_tuple__35; static PyObject *__pyx_tuple__36; static PyObject *__pyx_tuple__37; static PyObject *__pyx_tuple__38; static PyObject *__pyx_tuple__39; static PyObject *__pyx_tuple__40; static PyObject *__pyx_tuple__41; static PyObject *__pyx_tuple__42; static PyObject *__pyx_tuple__43; static PyObject *__pyx_tuple__44; static PyObject *__pyx_tuple__45; static PyObject *__pyx_tuple__46; static PyObject *__pyx_tuple__47; static PyObject *__pyx_tuple__48; static PyObject *__pyx_tuple__51; static PyObject *__pyx_tuple__52; static PyObject *__pyx_tuple__53; static PyObject *__pyx_tuple__54; static PyObject *__pyx_tuple__55; static PyObject *__pyx_tuple__56; static PyObject *__pyx_tuple__57; static PyObject *__pyx_tuple__58; static PyObject *__pyx_tuple__59; static PyObject *__pyx_tuple__60; static PyObject *__pyx_tuple__61; static PyObject *__pyx_tuple__62; static PyObject *__pyx_tuple__63; static PyObject *__pyx_tuple__64; static PyObject *__pyx_tuple__65; static PyObject *__pyx_tuple__66; static PyObject *__pyx_tuple__67; static PyObject *__pyx_tuple__68; static PyObject *__pyx_tuple__69; static PyObject *__pyx_tuple__70; static PyObject *__pyx_tuple__71; static PyObject *__pyx_tuple__72; static PyObject *__pyx_tuple__73; static PyObject *__pyx_tuple__74; static PyObject *__pyx_tuple__75; static PyObject *__pyx_tuple__76; static PyObject *__pyx_tuple__77; static PyObject *__pyx_tuple__79; static PyObject *__pyx_tuple__81; static PyObject *__pyx_tuple__83; static PyObject *__pyx_tuple__85; static PyObject *__pyx_tuple__87; static PyObject *__pyx_tuple__89; static PyObject *__pyx_tuple__91; static PyObject *__pyx_tuple__93; static PyObject *__pyx_codeobj__78; static PyObject *__pyx_codeobj__80; static PyObject *__pyx_codeobj__82; static PyObject *__pyx_codeobj__84; static PyObject *__pyx_codeobj__86; static PyObject *__pyx_codeobj__88; static PyObject *__pyx_codeobj__90; static PyObject *__pyx_codeobj__92; static PyObject *__pyx_codeobj__94; static PyObject *__pyx_codeobj__95; static PyObject *__pyx_codeobj__96; /* "src/llfuse/handlers.pxi":14 * ''' * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: # <<<<<<<<<<<<<< * try: * with lock: */ static void __pyx_f_6llfuse_4capi_fuse_init(CYTHON_UNUSED void *__pyx_v_userdata, CYTHON_UNUSED struct fuse_conn_info *__pyx_v_conn) { PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_init", 0); /* "src/llfuse/handlers.pxi":15 * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: # <<<<<<<<<<<<<< * with lock: * operations.init() */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":17 * try: * with lock: * operations.init() # <<<<<<<<<<<<<< * except BaseException as e: * handle_exc('init', e, NULL) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_init); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_13 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_14 = ((!(__pyx_t_13 != 0)) != 0); if (__pyx_t_14) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple_, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":18 * with lock: * operations.init() * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('init', e, NULL) * */ __pyx_t_15 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_15) { __Pyx_AddTraceback("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":19 * operations.init() * except BaseException as e: * handle_exc('init', e, NULL) # <<<<<<<<<<<<<< * * cdef void fuse_destroy (void *userdata) with gil: */ __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_init, __pyx_v_e, NULL); } /* "src/llfuse/handlers.pxi":18 * with lock: * operations.init() * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('init', e, NULL) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":14 * ''' * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: # <<<<<<<<<<<<<< * try: * with lock: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_WriteUnraisable("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":21 * handle_exc('init', e, NULL) * * cdef void fuse_destroy (void *userdata) with gil: # <<<<<<<<<<<<<< * # Note: called by fuse_session_destroy(), i.e. not as part of the * # main loop but only when llfuse.close() is called. */ static void __pyx_f_6llfuse_4capi_fuse_destroy(CYTHON_UNUSED void *__pyx_v_userdata) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_destroy", 0); /* "src/llfuse/handlers.pxi":26 * # (therefore we don't obtain the global lock) * global exc_info * try: # <<<<<<<<<<<<<< * operations.destroy() * except: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":27 * global exc_info * try: * operations.destroy() # <<<<<<<<<<<<<< * except: * if not exc_info: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_destroy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":28 * try: * operations.destroy() * except: # <<<<<<<<<<<<<< * if not exc_info: * exc_info = sys.exc_info() */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_destroy", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); /* "src/llfuse/handlers.pxi":29 * operations.destroy() * except: * if not exc_info: # <<<<<<<<<<<<<< * exc_info = sys.exc_info() * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __pyx_t_8 = ((!__pyx_t_7) != 0); if (__pyx_t_8) { /* "src/llfuse/handlers.pxi":30 * except: * if not exc_info: * exc_info = sys.exc_info() # <<<<<<<<<<<<<< * else: * log.exception('Exception after kill:') */ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_11))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (__pyx_t_10) { __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_10); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else { __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} } __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L13; } /*else*/ { /* "src/llfuse/handlers.pxi":32 * exc_info = sys.exc_info() * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, */ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_exception); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_L13:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_exception_handled; } __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":21 * handle_exc('init', e, NULL) * * cdef void fuse_destroy (void *userdata) with gil: # <<<<<<<<<<<<<< * # Note: called by fuse_session_destroy(), i.e. not as part of the * # main loop but only when llfuse.close() is called. */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_WriteUnraisable("llfuse.capi.fuse_destroy", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":34 * log.exception('Exception after kill:') * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef fuse_entry_param entry */ static void __pyx_f_6llfuse_4capi_fuse_lookup(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { struct fuse_entry_param __pyx_v_entry; int __pyx_v_ret; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_lookup", 0); /* "src/llfuse/handlers.pxi":39 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":41 * try: * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_lookup); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__3, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":42 * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_14 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":43 * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":44 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":45 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('lookup', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":44 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":46 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('lookup', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":47 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('lookup', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_lookup, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":46 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('lookup', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":49 * ret = handle_exc('lookup', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":50 * * if ret != 0: * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_lookup_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":34 * log.exception('Exception after kill:') * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef fuse_entry_param entry */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":53 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * ulong_t nlookup) with gil: * try: */ static void __pyx_f_6llfuse_4capi_fuse_forget(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, unsigned long __pyx_v_nlookup) { PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_forget", 0); /* "src/llfuse/handlers.pxi":55 * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, * ulong_t nlookup) with gil: * try: # <<<<<<<<<<<<<< * with lock: * operations.forget([(ino, nlookup)]) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":57 * try: * with lock: * operations.forget([(ino, nlookup)]) # <<<<<<<<<<<<<< * except BaseException as e: * handle_exc('forget', e, NULL) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_forget); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_unsigned_long(__pyx_v_nlookup); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_12) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__4, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":58 * with lock: * operations.forget([(ino, nlookup)]) * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('forget', e, NULL) * fuse_reply_none(req) */ __pyx_t_16 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":59 * operations.forget([(ino, nlookup)]) * except BaseException as e: * handle_exc('forget', e, NULL) # <<<<<<<<<<<<<< * fuse_reply_none(req) * */ __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_forget, __pyx_v_e, NULL); } /* "src/llfuse/handlers.pxi":58 * with lock: * operations.forget([(ino, nlookup)]) * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('forget', e, NULL) * fuse_reply_none(req) */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":60 * except BaseException as e: * handle_exc('forget', e, NULL) * fuse_reply_none(req) # <<<<<<<<<<<<<< * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, */ fuse_reply_none(__pyx_v_req); /* "src/llfuse/handlers.pxi":53 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * ulong_t nlookup) with gil: * try: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_WriteUnraisable("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":62 * fuse_reply_none(req) * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef c_stat stat */ static void __pyx_f_6llfuse_4capi_fuse_getattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, CYTHON_UNUSED struct fuse_file_info *__pyx_v_fi) { struct stat __pyx_v_stat; int __pyx_v_ret; int __pyx_v_timeout; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_getattr", 0); /* "src/llfuse/handlers.pxi":68 * cdef int timeout * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.getattr(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":70 * try: * with lock: * attr = operations.getattr(ino) # <<<<<<<<<<<<<< * * fill_c_stat(attr, &stat) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__5, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":72 * attr = operations.getattr(ino) * * fill_c_stat(attr, &stat) # <<<<<<<<<<<<<< * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_12 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":73 * * fill_c_stat(attr, &stat) * timeout = attr.attr_timeout # <<<<<<<<<<<<<< * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_timeout = __pyx_t_16; /* "src/llfuse/handlers.pxi":74 * fill_c_stat(attr, &stat) * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_attr(__pyx_v_req, (&__pyx_v_stat), __pyx_v_timeout); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":75 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":76 * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('getattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":75 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":77 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getattr', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":78 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('getattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_getattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":77 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":80 * ret = handle_exc('getattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":81 * * if ret != 0: * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_getattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":62 * fuse_reply_none(req) * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef c_stat stat */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":83 * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_setattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct stat *__pyx_v_stat, int __pyx_v_to_set, CYTHON_UNUSED struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; struct stat __pyx_v_stat_n; int __pyx_v_timeout; struct timespec __pyx_v_now; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_setattr", 0); /* "src/llfuse/handlers.pxi":90 * cdef timespec now * * try: # <<<<<<<<<<<<<< * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":91 * * try: * attr = EntryAttributes() # <<<<<<<<<<<<<< * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_EntryAttributes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":92 * try: * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): # <<<<<<<<<<<<<< * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: */ __pyx_t_7 = ((__pyx_v_to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW)) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":93 * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', */ __pyx_v_ret = clock_gettime(CLOCK_REALTIME, (&__pyx_v_now)); /* "src/llfuse/handlers.pxi":94 * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) */ __pyx_t_7 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":95 * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', # <<<<<<<<<<<<<< * strerror(errno.errno)) * */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/llfuse/handlers.pxi":96 * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) # <<<<<<<<<<<<<< * * # Type casting required on 64bit, where double */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_10) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = NULL; PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_11 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L12; } __pyx_L12:; goto __pyx_L11; } __pyx_L11:; /* "src/llfuse/handlers.pxi":100 * # Type casting required on 64bit, where double * # is smaller than long int. * if to_set & FUSE_SET_ATTR_ATIME: # <<<<<<<<<<<<<< * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_ATIME) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":101 * # is smaller than long int. * if to_set & FUSE_SET_ATTR_ATIME: * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 # <<<<<<<<<<<<<< * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: */ __pyx_t_4 = PyFloat_FromDouble((((double)__pyx_v_stat->st_atime) + (((double)GET_ATIME_NS(__pyx_v_stat)) * 1e-9))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":102 * if to_set & FUSE_SET_ATTR_ATIME: * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec */ __pyx_t_4 = __Pyx_PyInt_From_long(((__pyx_v_stat->st_atime * 1000000000) + GET_ATIME_NS(__pyx_v_stat))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 102; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 102; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L13; } /* "src/llfuse/handlers.pxi":103 * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: # <<<<<<<<<<<<<< * attr.st_atime = now.tv_sec * attr.st_atime_ns = now.tv_nsec */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_ATIME_NOW) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":104 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec # <<<<<<<<<<<<<< * attr.st_atime_ns = now.tv_nsec * else: */ __pyx_t_4 = __Pyx_PyInt_From_time_t(__pyx_v_now.tv_sec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":105 * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec * attr.st_atime_ns = now.tv_nsec # <<<<<<<<<<<<<< * else: * attr.st_atime = attr.st_atime_ns = None */ __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_now.tv_nsec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L13; } /*else*/ { /* "src/llfuse/handlers.pxi":107 * attr.st_atime_ns = now.tv_nsec * else: * attr.st_atime = attr.st_atime_ns = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_MTIME: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L13:; /* "src/llfuse/handlers.pxi":109 * attr.st_atime = attr.st_atime_ns = None * * if to_set & FUSE_SET_ATTR_MTIME: # <<<<<<<<<<<<<< * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MTIME) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":110 * * if to_set & FUSE_SET_ATTR_MTIME: * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 # <<<<<<<<<<<<<< * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: */ __pyx_t_4 = PyFloat_FromDouble((((double)__pyx_v_stat->st_mtime) + (((double)GET_MTIME_NS(__pyx_v_stat)) * 1e-9))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 110; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 110; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":111 * if to_set & FUSE_SET_ATTR_MTIME: * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec */ __pyx_t_4 = __Pyx_PyInt_From_long(((__pyx_v_stat->st_mtime * 1000000000) + GET_MTIME_NS(__pyx_v_stat))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 111; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 111; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L14; } /* "src/llfuse/handlers.pxi":112 * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: # <<<<<<<<<<<<<< * attr.st_mtime = now.tv_sec * attr.st_mtime_ns = now.tv_nsec */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MTIME_NOW) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":113 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec # <<<<<<<<<<<<<< * attr.st_mtime_ns = now.tv_nsec * else: */ __pyx_t_4 = __Pyx_PyInt_From_time_t(__pyx_v_now.tv_sec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":114 * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec * attr.st_mtime_ns = now.tv_nsec # <<<<<<<<<<<<<< * else: * attr.st_mtime = attr.st_mtime_ns = None */ __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_now.tv_nsec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 114; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 114; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L14; } /*else*/ { /* "src/llfuse/handlers.pxi":116 * attr.st_mtime_ns = now.tv_nsec * else: * attr.st_mtime = attr.st_mtime_ns = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_MODE: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 116; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 116; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L14:; /* "src/llfuse/handlers.pxi":118 * attr.st_mtime = attr.st_mtime_ns = None * * if to_set & FUSE_SET_ATTR_MODE: # <<<<<<<<<<<<<< * attr.st_mode = stat.st_mode * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MODE) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":119 * * if to_set & FUSE_SET_ATTR_MODE: * attr.st_mode = stat.st_mode # <<<<<<<<<<<<<< * else: * attr.st_mode = None */ __pyx_t_4 = __Pyx_PyInt_From_mode_t(__pyx_v_stat->st_mode); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L15; } /*else*/ { /* "src/llfuse/handlers.pxi":121 * attr.st_mode = stat.st_mode * else: * attr.st_mode = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_UID: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 121; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L15:; /* "src/llfuse/handlers.pxi":123 * attr.st_mode = None * * if to_set & FUSE_SET_ATTR_UID: # <<<<<<<<<<<<<< * attr.st_uid = stat.st_uid * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_UID) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":124 * * if to_set & FUSE_SET_ATTR_UID: * attr.st_uid = stat.st_uid # <<<<<<<<<<<<<< * else: * attr.st_uid = None */ __pyx_t_4 = __Pyx_PyInt_From_uid_t(__pyx_v_stat->st_uid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 124; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 124; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L16; } /*else*/ { /* "src/llfuse/handlers.pxi":126 * attr.st_uid = stat.st_uid * else: * attr.st_uid = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_GID: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 126; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L16:; /* "src/llfuse/handlers.pxi":128 * attr.st_uid = None * * if to_set & FUSE_SET_ATTR_GID: # <<<<<<<<<<<<<< * attr.st_gid = stat.st_gid * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_GID) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":129 * * if to_set & FUSE_SET_ATTR_GID: * attr.st_gid = stat.st_gid # <<<<<<<<<<<<<< * else: * attr.st_gid = None */ __pyx_t_4 = __Pyx_PyInt_From_gid_t(__pyx_v_stat->st_gid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 129; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 129; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L17; } /*else*/ { /* "src/llfuse/handlers.pxi":131 * attr.st_gid = stat.st_gid * else: * attr.st_gid = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_SIZE: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 131; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L17:; /* "src/llfuse/handlers.pxi":133 * attr.st_gid = None * * if to_set & FUSE_SET_ATTR_SIZE: # <<<<<<<<<<<<<< * attr.st_size = stat.st_size * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_SIZE) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":134 * * if to_set & FUSE_SET_ATTR_SIZE: * attr.st_size = stat.st_size # <<<<<<<<<<<<<< * else: * attr.st_size = None */ __pyx_t_4 = __Pyx_PyInt_From_off_t(__pyx_v_stat->st_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 134; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_size, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 134; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L18; } /*else*/ { /* "src/llfuse/handlers.pxi":136 * attr.st_size = stat.st_size * else: * attr.st_size = None # <<<<<<<<<<<<<< * * with lock: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_size, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 136; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L18:; /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_13 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_11 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_11))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (__pyx_t_5) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); /*try:*/ { /* "src/llfuse/handlers.pxi":139 * * with lock: * attr = operations.setattr(ino, attr) # <<<<<<<<<<<<<< * * fill_c_stat(attr, &stat_n) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_setattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_11 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_12, __pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); __Pyx_INCREF(__pyx_v_attr); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_12, __pyx_v_attr); __Pyx_GIVEREF(__pyx_v_attr); __pyx_t_11 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_attr, __pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L32_try_end; __pyx_L25_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); __pyx_t_11 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_11, NULL); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_7 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __pyx_t_18 = ((!(__pyx_t_7 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_8); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_8 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L26_exception_handled; } __pyx_L27_except_error:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); goto __pyx_L3_error; __pyx_L26_exception_handled:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_L32_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_13) { __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_tuple__6, NULL); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; } goto __pyx_L24; } __pyx_L24:; } goto __pyx_L36; __pyx_L19_error:; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L3_error; __pyx_L36:; } /* "src/llfuse/handlers.pxi":141 * attr = operations.setattr(ino, attr) * * fill_c_stat(attr, &stat_n) # <<<<<<<<<<<<<< * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) */ __pyx_t_8 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat_n)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/llfuse/handlers.pxi":142 * * fill_c_stat(attr, &stat_n) * timeout = attr.attr_timeout # <<<<<<<<<<<<<< * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_timeout = __pyx_t_19; /* "src/llfuse/handlers.pxi":143 * fill_c_stat(attr, &stat_n) * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_attr(__pyx_v_req, (&__pyx_v_stat_n), __pyx_v_timeout); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/llfuse/handlers.pxi":144 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":145 * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('setattr', e, req) */ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 145; __pyx_clineno = __LINE__; goto __pyx_L42_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 145; __pyx_clineno = __LINE__; goto __pyx_L42_error;} __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":144 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L43; } /*exception exit:*/{ __pyx_L42_error:; __pyx_t_13 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_17 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_17, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_16, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_16, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_17, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_16, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_17 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L43:; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":146 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setattr', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":147 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('setattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_setattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":146 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L54; } __pyx_L54:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":149 * ret = handle_exc('setattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":150 * * if ret != 0: * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_11))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (!__pyx_t_9) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_11)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_11); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_10 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_11) { PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); __pyx_t_11 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_12, __pyx_kp_u_fuse_setattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L55; } __pyx_L55:; /* "src/llfuse/handlers.pxi":83 * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_WriteUnraisable("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":152 * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ static void __pyx_f_6llfuse_4capi_fuse_readlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino) { int __pyx_v_ret; char *__pyx_v_name; PyObject *__pyx_v_target = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; char *__pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; Py_ssize_t __pyx_t_23; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_readlink", 0); /* "src/llfuse/handlers.pxi":155 * cdef int ret * cdef char* name * try: # <<<<<<<<<<<<<< * with lock: * target = operations.readlink(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":157 * try: * with lock: * target = operations.readlink(ino) # <<<<<<<<<<<<<< * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_readlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_target = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":158 * with lock: * target = operations.readlink(ino) * name = PyBytes_AsString(target) # <<<<<<<<<<<<<< * ret = fuse_reply_readlink(req, name) * except FUSEError as e: */ if (unlikely(!__pyx_v_target)) { __Pyx_RaiseUnboundLocalError("target"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 158; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = PyBytes_AsString(__pyx_v_target); if (unlikely(__pyx_t_16 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 158; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_name = __pyx_t_16; /* "src/llfuse/handlers.pxi":159 * target = operations.readlink(ino) * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_readlink(__pyx_v_req, __pyx_v_name); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":160 * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 160; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 160; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":161 * ret = fuse_reply_readlink(req, name) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('readlink', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":160 * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":162 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readlink', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 162; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":163 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('readlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_readlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":162 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":165 * ret = handle_exc('readlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":166 * * if ret != 0: * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_23 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_23 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_23); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_23, __pyx_kp_u_fuse_readlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_23, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":152 * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_target); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":168 * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_mknod(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode, dev_t __pyx_v_rdev) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_mknod", 0); /* "src/llfuse/handlers.pxi":173 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":174 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 174; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":176 * ctx = get_request_context(req) * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, # <<<<<<<<<<<<<< * rdev, ctx) * fill_entry_param(attr, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_mknod); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); /* "src/llfuse/handlers.pxi":177 * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_13 = __Pyx_PyInt_From_dev_t(__pyx_v_rdev); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 177; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } __pyx_t_16 = PyTuple_New(5+__pyx_t_15); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_16); if (__pyx_t_14) { PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = NULL; } PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_16, 4+__pyx_t_15, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_16, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_16); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_18 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_19 = ((!(__pyx_t_18 != 0)) != 0); if (__pyx_t_19) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_16); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":178 * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":179 * rdev, ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":180 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_16 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 180; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_16, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 180; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":181 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('mknod', e, req) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_13); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); } /* "src/llfuse/handlers.pxi":180 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_17, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_20 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_17, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":182 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mknod', e, req) * */ __pyx_t_21 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 182; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":183 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('mknod', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_mknod, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":182 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mknod', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":185 * ret = handle_exc('mknod', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/llfuse/handlers.pxi":186 * * if ret != 0: * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_13))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } if (!__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_15 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_15, __pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_15, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":168 * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_16); __Pyx_WriteUnraisable("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":188 * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_mkdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_mkdir", 0); /* "src/llfuse/handlers.pxi":193 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * # Force the entry type to directory. We need to explicitly cast, * # because on BSD the S_* are not of type mode_t. */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":196 * # Force the entry type to directory. We need to explicitly cast, * # because on BSD the S_* are not of type mode_t. * mode = ((mode & ~S_IFMT) | S_IFDIR) # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ __pyx_v_mode = ((mode_t)((__pyx_v_mode & (~S_IFMT)) | S_IFDIR)); /* "src/llfuse/handlers.pxi":197 * # because on BSD the S_* are not of type mode_t. * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 197; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":199 * ctx = get_request_context(req) * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_mkdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__9, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":200 * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":201 * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":202 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 202; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 202; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":203 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('mkdir', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":202 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":204 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mkdir', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 204; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":205 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('mkdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_mkdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":204 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mkdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":207 * ret = handle_exc('mkdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":208 * * if ret != 0: * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":188 * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":210 * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_unlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_unlink", 0); /* "src/llfuse/handlers.pxi":213 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.unlink(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":215 * try: * with lock: * operations.unlink(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_unlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__10, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":216 * with lock: * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":217 * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":218 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('unlink', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":217 * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":219 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('unlink', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":220 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('unlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_unlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":219 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('unlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":222 * ret = handle_exc('unlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":223 * * if ret != 0: * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_unlink_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":210 * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":225 * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_rmdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_rmdir", 0); /* "src/llfuse/handlers.pxi":228 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":230 * try: * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_rmdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__11, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":231 * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":232 * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 232; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 232; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":233 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('rmdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":232 * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":234 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rmdir', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":235 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('rmdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_rmdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":234 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rmdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":237 * ret = handle_exc('rmdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":238 * * if ret != 0: * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":225 * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":240 * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_symlink(fuse_req_t __pyx_v_req, const char *__pyx_v_link, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_symlink", 0); /* "src/llfuse/handlers.pxi":245 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":246 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":248 * ctx = get_request_context(req) * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), # <<<<<<<<<<<<<< * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_symlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); /* "src/llfuse/handlers.pxi":249 * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_12 = PyBytes_FromString(__pyx_v_link); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 249; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":250 * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":251 * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":252 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":253 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('symlink', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":252 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":254 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('symlink', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 254; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":255 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('symlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_symlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":254 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('symlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":257 * ret = handle_exc('symlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":258 * * if ret != 0: * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_symlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":240 * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":260 * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_rename(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_rename", 0); /* "src/llfuse/handlers.pxi":264 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.rename(parent, PyBytes_FromString(name), */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":266 * try: * with lock: * operations.rename(parent, PyBytes_FromString(name), # <<<<<<<<<<<<<< * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_rename); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); /* "src/llfuse/handlers.pxi":267 * with lock: * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_12 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_newparent); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } __pyx_t_16 = PyTuple_New(4+__pyx_t_15); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_16); if (__pyx_t_14) { PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = NULL; } PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_16, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_16); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_18 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_19 = ((!(__pyx_t_18 != 0)) != 0); if (__pyx_t_19) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_16); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":268 * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":269 * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_16 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_16, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":270 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('rename', e, req) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_13); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); } /* "src/llfuse/handlers.pxi":269 * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_17, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_20 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_17, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":271 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rename', e, req) * */ __pyx_t_21 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":272 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('rename', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_rename, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":271 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rename', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":274 * ret = handle_exc('rename', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/llfuse/handlers.pxi":275 * * if ret != 0: * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_13))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } if (!__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_15 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_15, __pyx_kp_u_fuse_rename_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_15, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":260 * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_16); __Pyx_WriteUnraisable("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":277 * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_link(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_link", 0); /* "src/llfuse/handlers.pxi":282 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":284 * try: * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_link); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_newparent); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__14, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":285 * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":286 * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":287 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":288 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('link', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":287 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":289 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('link', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":290 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('link', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_link, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":289 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('link', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":292 * ret = handle_exc('link', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":293 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":277 * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":296 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_open(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; uint64_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_open", 0); /* "src/llfuse/handlers.pxi":299 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * fi.fh = operations.open(ino, fi.flags) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":301 * try: * with lock: * fi.fh = operations.open(ino, fi.flags) # <<<<<<<<<<<<<< * * # Cached file data does not need to be invalidated. */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_open); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_fi->flags); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyInt_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_15 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_fi->fh = __pyx_t_15; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__15, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":305 * # Cached file data does not need to be invalidated. * # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ * fi.keep_cache = 1 # <<<<<<<<<<<<<< * * ret = fuse_reply_open(req, fi) */ __pyx_v_fi->keep_cache = 1; /* "src/llfuse/handlers.pxi":307 * fi.keep_cache = 1 * * ret = fuse_reply_open(req, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_open(__pyx_v_req, __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":308 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":309 * ret = fuse_reply_open(req, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('open', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":308 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":310 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('open', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":311 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('open', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_open, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":310 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('open', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":313 * ret = handle_exc('open', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":314 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_23, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_23, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_23 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_23); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_23, 0+__pyx_t_13, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_23, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_23, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":296 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_23); __Pyx_WriteUnraisable("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":316 * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_read(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_read", 0); /* "src/llfuse/handlers.pxi":322 * cdef char* cbuf * * try: # <<<<<<<<<<<<<< * with lock: * buf = operations.read(fi.fh, off, size) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":324 * try: * with lock: * buf = operations.read(fi.fh, off, size) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_read); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__16, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":325 * with lock: * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_19 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_19 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":326 * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":327 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":328 * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('read', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":327 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":329 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('read', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":330 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('read', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_read, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":329 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('read', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":332 * ret = handle_exc('read', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":333 * * if ret != 0: * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_read_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":316 * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":335 * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_write(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, const char *__pyx_v_buf, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; size_t __pyx_v_len_; PyObject *__pyx_v_pbuf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; size_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_t_24; char const *__pyx_t_25; PyObject *__pyx_t_26 = NULL; char const *__pyx_t_27; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_write", 0); /* "src/llfuse/handlers.pxi":341 * * # GCC thinks this may end up uninitialized * len_ = 0 # <<<<<<<<<<<<<< * * try: */ __pyx_v_len_ = 0; /* "src/llfuse/handlers.pxi":343 * len_ = 0 * * try: # <<<<<<<<<<<<<< * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":344 * * try: * pbuf = PyBytes_FromStringAndSize(buf, size) # <<<<<<<<<<<<<< * with lock: * len_ = operations.write(fi.fh, off, pbuf) */ __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_pbuf = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":346 * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: * len_ = operations.write(fi.fh, off, pbuf) # <<<<<<<<<<<<<< * ret = fuse_reply_write(req, len_) * if ret != 0: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_write); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_pbuf); PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_v_pbuf); __Pyx_GIVEREF(__pyx_v_pbuf); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_len_ = __pyx_t_15; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__17, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":347 * with lock: * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) */ __pyx_v_ret = fuse_reply_write(__pyx_v_req, __pyx_v_len_); /* "src/llfuse/handlers.pxi":348 * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":349 * ret = fuse_reply_write(req, len_) * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_19 = PyTuple_New(1+1); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_19); PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_19, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_19, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_19 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_19); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_write_fail); PyTuple_SET_ITEM(__pyx_t_19, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_write_fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_write_fail); PyTuple_SET_ITEM(__pyx_t_19, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_19, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L29; } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":350 * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * if ret != 0: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_4, &__pyx_t_19) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_19); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":351 * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); /* "src/llfuse/handlers.pxi":352 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":353 * ret = fuse_reply_err(req, e.errno) * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('write', e, req) */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_21 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_21); __pyx_t_22 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_22)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_22); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_22) { __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_21); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_GOTREF(__pyx_t_8); } else { __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_22); __Pyx_GIVEREF(__pyx_t_22); __pyx_t_22 = NULL; PyTuple_SET_ITEM(__pyx_t_23, 0+1, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = 0; __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_23, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_23 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_23)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_23); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_13 = 1; } } __pyx_t_21 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_23) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_23); __Pyx_GIVEREF(__pyx_t_23); __pyx_t_23 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_err_d_fail); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_err_d_fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_err_d_fail); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_21, 2+__pyx_t_13, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L37; } __pyx_L37:; } /* "src/llfuse/handlers.pxi":350 * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * if ret != 0: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_26); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_26); __pyx_t_20 = __pyx_lineno; __pyx_t_24 = __pyx_clineno; __pyx_t_25 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_26); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_26); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_26 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_24; __pyx_filename = __pyx_t_25; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":354 * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('write', e, req) * */ __pyx_t_24 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_24) { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_19, &__pyx_t_4, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_19); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":355 * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: * ret = handle_exc('write', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_write, __pyx_v_e, __pyx_v_req); /* "src/llfuse/handlers.pxi":357 * ret = handle_exc('write', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":358 * * if ret != 0: * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_error); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_21); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_23 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_23)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_23); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_23) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_23); __Pyx_GIVEREF(__pyx_t_23); __pyx_t_23 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_22, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_21))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_21); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_21); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_21, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_err_failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_err_failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_err_failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_21, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L49; } __pyx_L49:; } /* "src/llfuse/handlers.pxi":354 * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('write', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } /*exception exit:*/{ __pyx_L47_error:; __pyx_t_26 = 0; __pyx_t_16 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_5); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_26, &__pyx_t_16, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_26, &__pyx_t_16, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_26); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_5); __pyx_t_24 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_27 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_5); } __Pyx_XGIVEREF(__pyx_t_26); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ErrRestore(__pyx_t_26, __pyx_t_16, __pyx_t_9); __pyx_t_26 = 0; __pyx_t_16 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_5 = 0; __pyx_lineno = __pyx_t_24; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_27; goto __pyx_L5_except_error; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":335 * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_XDECREF(__pyx_t_23); __Pyx_WriteUnraisable("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_pbuf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":360 * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_flush(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_flush", 0); /* "src/llfuse/handlers.pxi":363 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.flush(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":365 * try: * with lock: * operations.flush(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_flush); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__18, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":366 * with lock: * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":367 * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":368 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('flush', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":367 * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":369 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('flush', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":370 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('flush', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_flush, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":369 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('flush', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":372 * ret = handle_exc('flush', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":373 * * if ret != 0: * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_flush_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":360 * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":375 * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_release(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_release", 0); /* "src/llfuse/handlers.pxi":378 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.release(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":380 * try: * with lock: * operations.release(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_release); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__19, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":381 * with lock: * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":382 * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 382; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 382; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":383 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('release', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":382 * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":384 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('release', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 384; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":385 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('release', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_release, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":384 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('release', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":387 * ret = handle_exc('release', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":388 * * if ret != 0: * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_release_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_release_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_release_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":375 * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":390 * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_fsync(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_fsync", 0); /* "src/llfuse/handlers.pxi":394 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.fsync(fi.fh, datasync != 0) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":396 * try: * with lock: * operations.fsync(fi.fh, datasync != 0) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_fsync); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyBool_FromLong((__pyx_v_datasync != 0)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__20, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":397 * with lock: * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":398 * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":399 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('fsync', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 399; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 399; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":398 * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":400 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsync', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":401 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('fsync', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_fsync, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":400 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsync', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":403 * ret = handle_exc('fsync', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":404 * * if ret != 0: * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":390 * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":406 * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_opendir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; uint64_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; Py_ssize_t __pyx_t_23; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_opendir", 0); /* "src/llfuse/handlers.pxi":409 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * fi.fh = operations.opendir(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":411 * try: * with lock: * fi.fh = operations.opendir(ino) # <<<<<<<<<<<<<< * * ret = fuse_reply_open(req, fi) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_opendir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyInt_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_13 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_fi->fh = __pyx_t_13; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__21, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":413 * fi.fh = operations.opendir(ino) * * ret = fuse_reply_open(req, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_open(__pyx_v_req, __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":414 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":415 * ret = fuse_reply_open(req, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('opendir', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":414 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":416 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('opendir', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":417 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('opendir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_opendir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":416 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('opendir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":419 * ret = handle_exc('opendir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":420 * * if ret != 0: * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_23 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_23 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_23); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_23, __pyx_kp_u_fuse_opendir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_23, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":406 * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":422 * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_readdir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; char *__pyx_v_cname; char *__pyx_v_buf; size_t __pyx_v_len_; size_t __pyx_v_acc_size; struct stat __pyx_v_stat; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_next_ = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *(*__pyx_t_15)(PyObject *); PyObject *(*__pyx_t_16)(PyObject *); int __pyx_t_17; char *__pyx_t_18; off_t __pyx_t_19; PyObject *__pyx_t_20 = NULL; int __pyx_t_21; int __pyx_t_22; int __pyx_t_23; char const *__pyx_t_24; PyObject *__pyx_t_25 = NULL; char const *__pyx_t_26; PyObject *__pyx_t_27 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_readdir", 0); /* "src/llfuse/handlers.pxi":431 * * # GCC thinks this may end up uninitialized * ret = 0 # <<<<<<<<<<<<<< * * try: */ __pyx_v_ret = 0; /* "src/llfuse/handlers.pxi":433 * ret = 0 * * try: # <<<<<<<<<<<<<< * acc_size = 0 * buf = NULL */ /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":434 * * try: * acc_size = 0 # <<<<<<<<<<<<<< * buf = NULL * with lock: */ __pyx_v_acc_size = 0; /* "src/llfuse/handlers.pxi":435 * try: * acc_size = 0 * buf = NULL # <<<<<<<<<<<<<< * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): */ __pyx_v_buf = NULL; /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":437 * buf = NULL * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): # <<<<<<<<<<<<<< * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_readdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { __pyx_t_6 = __pyx_t_4; __Pyx_INCREF(__pyx_t_6); __pyx_t_13 = 0; __pyx_t_15 = NULL; } else { __pyx_t_13 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { if (likely(!__pyx_t_15)) { if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_6, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #endif } else { if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_6, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #endif } } else { __pyx_t_4 = __pyx_t_15(__pyx_t_6); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } break; } __Pyx_GOTREF(__pyx_t_4); } if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { PyObject* sequence = __pyx_t_4; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_14 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 2); } else { __pyx_t_14 = PyList_GET_ITEM(sequence, 0); __pyx_t_8 = PyList_GET_ITEM(sequence, 1); __pyx_t_7 = PyList_GET_ITEM(sequence, 2); } __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); #else __pyx_t_14 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { Py_ssize_t index = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_16 = Py_TYPE(__pyx_t_12)->tp_iternext; index = 0; __pyx_t_14 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_14)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_14); index = 1; __pyx_t_8 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_8)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_8); index = 2; __pyx_t_7 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_7)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_12), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_t_16 = NULL; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L31_unpacking_done; __pyx_L30_unpacking_failed:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_16 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_L31_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF_SET(__pyx_v_attr, __pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF_SET(__pyx_v_next_, __pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":438 * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: # <<<<<<<<<<<<<< * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) */ __pyx_t_17 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":439 * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) # <<<<<<<<<<<<<< * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) */ __pyx_v_buf = ((char *)malloc((__pyx_v_size * (sizeof(char))))); goto __pyx_L32; } __pyx_L32:; /* "src/llfuse/handlers.pxi":440 * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) # <<<<<<<<<<<<<< * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, */ __pyx_t_18 = PyBytes_AsString(__pyx_v_name); if (unlikely(__pyx_t_18 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 440; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_v_cname = __pyx_t_18; /* "src/llfuse/handlers.pxi":441 * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) # <<<<<<<<<<<<<< * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":443 * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) # <<<<<<<<<<<<<< * if len_ > (size - acc_size): * break */ __pyx_t_19 = __Pyx_PyInt_As_off_t(__pyx_v_next_); if (unlikely((__pyx_t_19 == (off_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L20_error;} /* "src/llfuse/handlers.pxi":442 * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, # <<<<<<<<<<<<<< * cname, &stat, next_) * if len_ > (size - acc_size): */ __pyx_v_len_ = fuse_add_direntry(__pyx_v_req, (__pyx_v_buf + __pyx_v_acc_size), (__pyx_v_size - __pyx_v_acc_size), __pyx_v_cname, (&__pyx_v_stat), __pyx_t_19); /* "src/llfuse/handlers.pxi":444 * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) * if len_ > (size - acc_size): # <<<<<<<<<<<<<< * break * acc_size += len_ */ __pyx_t_17 = ((__pyx_v_len_ > (__pyx_v_size - __pyx_v_acc_size)) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":445 * cname, &stat, next_) * if len_ > (size - acc_size): * break # <<<<<<<<<<<<<< * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) */ goto __pyx_L29_break; } /* "src/llfuse/handlers.pxi":446 * if len_ > (size - acc_size): * break * acc_size += len_ # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: */ __pyx_v_acc_size = (__pyx_v_acc_size + __pyx_v_len_); /* "src/llfuse/handlers.pxi":437 * buf = NULL * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): # <<<<<<<<<<<<<< * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) */ } __pyx_L29_break:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L27_try_end; __pyx_L20_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_4, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_20); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_20); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __pyx_t_21 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_21) { __Pyx_GIVEREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_6, __pyx_t_4, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_4 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L21_exception_handled; } __pyx_L22_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L6_error; __pyx_L21_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L27_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__22, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L19; } __pyx_L19:; } goto __pyx_L37; __pyx_L14_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L6_error; __pyx_L37:; } /* "src/llfuse/handlers.pxi":447 * break * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_buf, __pyx_v_acc_size); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L13_try_end; __pyx_L6_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":448 * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_22 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_22) { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":449 * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('readdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_22 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_22 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_22); } /* "src/llfuse/handlers.pxi":448 * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L44; } /*exception exit:*/{ __pyx_L43_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_25 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_20, &__pyx_t_25); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_25); __pyx_t_22 = __pyx_lineno; __pyx_t_23 = __pyx_clineno; __pyx_t_24 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_20, __pyx_t_25); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_25 = 0; __pyx_lineno = __pyx_t_22; __pyx_clineno = __pyx_t_23; __pyx_filename = __pyx_t_24; goto __pyx_L8_except_error; } __pyx_L44:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L7_exception_handled; } /* "src/llfuse/handlers.pxi":450 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readdir', e, req) * finally: */ __pyx_t_23 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_23) { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_4, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":451 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('readdir', e, req) # <<<<<<<<<<<<<< * finally: * if buf != NULL: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_readdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":450 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readdir', e, req) * finally: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L55; } __pyx_L55:; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L7_exception_handled; } goto __pyx_L8_except_error; __pyx_L8_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L4_error; __pyx_L7_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L13_try_end:; } } /* "src/llfuse/handlers.pxi":453 * ret = handle_exc('readdir', e, req) * finally: * if buf != NULL: # <<<<<<<<<<<<<< * stdlib.free(buf) * */ /*finally:*/ { /*normal exit:*/{ __pyx_t_21 = ((__pyx_v_buf != NULL) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":454 * finally: * if buf != NULL: * stdlib.free(buf) # <<<<<<<<<<<<<< * * if ret != 0: */ free(__pyx_v_buf); goto __pyx_L56; } __pyx_L56:; goto __pyx_L5; } /*exception exit:*/{ __pyx_L4_error:; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_25 = 0; __pyx_t_20 = 0; __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_25, &__pyx_t_20, &__pyx_t_9); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0)) __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_25); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_9); __pyx_t_23 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_26 = __pyx_filename; { /* "src/llfuse/handlers.pxi":453 * ret = handle_exc('readdir', e, req) * finally: * if buf != NULL: # <<<<<<<<<<<<<< * stdlib.free(buf) * */ __pyx_t_21 = ((__pyx_v_buf != NULL) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":454 * finally: * if buf != NULL: * stdlib.free(buf) # <<<<<<<<<<<<<< * * if ret != 0: */ free(__pyx_v_buf); goto __pyx_L59; } __pyx_L59:; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_25); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_20, __pyx_t_9); } __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_1); __Pyx_ErrRestore(__pyx_t_3, __pyx_t_2, __pyx_t_1); __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_25 = 0; __pyx_t_20 = 0; __pyx_t_9 = 0; __pyx_lineno = __pyx_t_23; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_26; goto __pyx_L1_error; } __pyx_L5:; } /* "src/llfuse/handlers.pxi":456 * stdlib.free(buf) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_21 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":457 * * if ret != 0: * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_14 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_14); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_27 = PyTuple_New(1+1); if (unlikely(!__pyx_t_27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_27); PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_27, 0+1, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_27, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_27 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_27); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_27, 0+__pyx_t_13, __pyx_kp_u_fuse_readdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_readdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_27, 1+__pyx_t_13, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_27, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L60; } __pyx_L60:; /* "src/llfuse/handlers.pxi":422 * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_27); __Pyx_WriteUnraisable("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_next_); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":459 * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_releasedir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_releasedir", 0); /* "src/llfuse/handlers.pxi":462 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.releasedir(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":464 * try: * with lock: * operations.releasedir(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_releasedir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__23, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":465 * with lock: * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":466 * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":467 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('releasedir', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":466 * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":468 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('releasedir', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 468; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":469 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('releasedir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_releasedir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":468 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('releasedir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":471 * ret = handle_exc('releasedir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":472 * * if ret != 0: * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_releasedir_fuse_reply__fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":459 * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":475 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_fsyncdir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_fsyncdir", 0); /* "src/llfuse/handlers.pxi":479 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.fsyncdir(fi.fh, datasync != 0) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":481 * try: * with lock: * operations.fsyncdir(fi.fh, datasync != 0) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_fsyncdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyBool_FromLong((__pyx_v_datasync != 0)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__24, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":482 * with lock: * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":483 * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":484 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('fsyncdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":483 * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":485 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsyncdir', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 485; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":486 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('fsyncdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_fsyncdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":485 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsyncdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":488 * ret = handle_exc('fsyncdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":489 * * if ret != 0: * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":475 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":492 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef statvfs cstats */ static void __pyx_f_6llfuse_4capi_fuse_statfs(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino) { int __pyx_v_ret; struct statvfs __pyx_v_cstats; PyObject *__pyx_v_stats = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; char const *__pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_statfs", 0); /* "src/llfuse/handlers.pxi":497 * * # We don't set all the components * string.memset(&cstats, 0, sizeof(cstats)) # <<<<<<<<<<<<<< * try: * with lock: */ memset((&__pyx_v_cstats), 0, (sizeof(__pyx_v_cstats))); /* "src/llfuse/handlers.pxi":498 * # We don't set all the components * string.memset(&cstats, 0, sizeof(cstats)) * try: # <<<<<<<<<<<<<< * with lock: * stats = operations.statfs() */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":500 * try: * with lock: * stats = operations.statfs() # <<<<<<<<<<<<<< * * fill_statvfs(stats, &cstats) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_statfs); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_stats = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_13 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_14 = ((!(__pyx_t_13 != 0)) != 0); if (__pyx_t_14) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__25, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":502 * stats = operations.statfs() * * fill_statvfs(stats, &cstats) # <<<<<<<<<<<<<< * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: */ if (unlikely(!__pyx_v_stats)) { __Pyx_RaiseUnboundLocalError("stats"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_7 = __pyx_f_6llfuse_4capi_fill_statvfs(__pyx_v_stats, (&__pyx_v_cstats)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":503 * * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_statfs(__pyx_v_req, (&__pyx_v_cstats)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":504 * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_15) { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":505 * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('statfs', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 505; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_15 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 505; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_15); } /* "src/llfuse/handlers.pxi":504 * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_12 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_12, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_15 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_12, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_12 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_15; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":506 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('statfs', e, req) * */ __pyx_t_16 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 506; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":507 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('statfs', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_statfs, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":506 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('statfs', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":509 * ret = handle_exc('statfs', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_14 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_14) { /* "src/llfuse/handlers.pxi":510 * * if ret != 0: * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * IF TARGET_PLATFORM == 'darwin': */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_19); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_19); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_19); __Pyx_GIVEREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_statfs_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":492 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef statvfs cstats */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_stats); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":534 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_setxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, const char *__pyx_v_cvalue, size_t __pyx_v_size, CYTHON_UNUSED int __pyx_v_flags) { int __pyx_v_ret; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_setxattr", 0); /* "src/llfuse/handlers.pxi":538 * cdef int ret * * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * value = PyBytes_FromStringAndSize(cvalue, size) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":539 * * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * value = PyBytes_FromStringAndSize(cvalue, size) * */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 539; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":540 * try: * name = PyBytes_FromString(cname) * value = PyBytes_FromStringAndSize(cvalue, size) # <<<<<<<<<<<<<< * * # Special case for deadlock debugging */ __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_v_cvalue, __pyx_v_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_value = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":543 * * # Special case for deadlock debugging * if ino == FUSE_ROOT_ID and string.strcmp(cname, 'fuse_stacktrace') == 0: # <<<<<<<<<<<<<< * operations.stacktrace() * else: */ __pyx_t_6 = ((__pyx_v_ino == FUSE_ROOT_ID) != 0); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L12_bool_binop_done; } __pyx_t_6 = ((strcmp(__pyx_v_cname, __pyx_k_fuse_stacktrace) == 0) != 0); __pyx_t_5 = __pyx_t_6; __pyx_L12_bool_binop_done:; if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":544 * # Special case for deadlock debugging * if ino == FUSE_ROOT_ID and string.strcmp(cname, 'fuse_stacktrace') == 0: * operations.stacktrace() # <<<<<<<<<<<<<< * else: * IF TARGET_PLATFORM == 'freebsd': */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_stacktrace); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L11; } /*else*/ { /* "src/llfuse/handlers.pxi":548 * IF TARGET_PLATFORM == 'freebsd': * # No known flags * with lock: # <<<<<<<<<<<<<< * operations.setxattr(ino, name, value) * ELSE: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (__pyx_t_10) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else { __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L14_error;} } __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { /* "src/llfuse/handlers.pxi":549 * # No known flags * with lock: * operations.setxattr(ino, name, value) # <<<<<<<<<<<<<< * ELSE: * # Make sure we know all the flags */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_setxattr); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_10) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __Pyx_INCREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 549; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L27_try_end; __pyx_L20_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":548 * IF TARGET_PLATFORM == 'freebsd': * # No known flags * with lock: # <<<<<<<<<<<<<< * operations.setxattr(ino, name, value) * ELSE: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_7, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_15); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_7, __pyx_t_15); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_5 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __pyx_t_6 = ((!(__pyx_t_5 != 0)) != 0); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_7, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_7 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L21_exception_handled; } __pyx_L22_except_error:; __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); goto __pyx_L3_error; __pyx_L21_exception_handled:; __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_L27_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_9) { __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__26, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } goto __pyx_L19; } __pyx_L19:; } goto __pyx_L31; __pyx_L14_error:; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L3_error; __pyx_L31:; } } __pyx_L11:; /* "src/llfuse/handlers.pxi":570 * operations.setxattr(ino, name, value) * * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":571 * * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_7, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __pyx_v_e = __pyx_t_7; /*try:*/ { /* "src/llfuse/handlers.pxi":572 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('setxattr', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L37_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L37_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":571 * * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L38; } /*exception exit:*/{ __pyx_L37_error:; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_16, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_13, &__pyx_t_12) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_13, &__pyx_t_12); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_16, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_9, __pyx_t_13, __pyx_t_12); __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L38:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":573 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setxattr', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_7, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 573; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_7); __pyx_v_e = __pyx_t_7; /*try:*/ { /* "src/llfuse/handlers.pxi":574 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('setxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_setxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":573 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L49; } __pyx_L49:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":576 * ret = handle_exc('setxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_6 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_6) { /* "src/llfuse/handlers.pxi":577 * * if ret != 0: * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * IF TARGET_PLATFORM == 'darwin': */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_21) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_14, __pyx_kp_u_fuse_setxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L50; } __pyx_L50:; /* "src/llfuse/handlers.pxi":534 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_15); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":592 * fuse_getxattr(req, ino, cname, size) * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_getxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, size_t __pyx_v_size) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_getxattr", 0); /* "src/llfuse/handlers.pxi":597 * cdef ssize_t len_ * cdef char *cbuf * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":598 * cdef char *cbuf * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * buf = operations.getxattr(ino, name) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 598; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":600 * name = PyBytes_FromString(cname) * with lock: * buf = operations.getxattr(ino, name) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_13); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_13 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__27, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":601 * with lock: * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * * if size == 0: */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 601; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_17 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_17 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 601; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":603 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * * if size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: */ __pyx_t_16 = ((__pyx_v_size == 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":604 * * if size == 0: * ret = fuse_reply_xattr(req, len_) # <<<<<<<<<<<<<< * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_v_ret = fuse_reply_xattr(__pyx_v_req, __pyx_v_len_); goto __pyx_L29; } /* "src/llfuse/handlers.pxi":605 * if size == 0: * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * else: */ __pyx_t_16 = ((((size_t)__pyx_v_len_) <= __pyx_v_size) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":606 * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, errno.ERANGE) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); goto __pyx_L29; } /*else*/ { /* "src/llfuse/handlers.pxi":608 * ret = fuse_reply_buf(req, cbuf, len_) * else: * ret = fuse_reply_err(req, errno.ERANGE) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, ERANGE); } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; /* "src/llfuse/handlers.pxi":609 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":610 * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('getxattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 610; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 610; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":609 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":611 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getxattr', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 611; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":612 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('getxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_getxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":611 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L47; } __pyx_L47:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":614 * ret = handle_exc('getxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":615 * * if ret != 0: * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_12, __pyx_kp_u_fuse_getxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L48; } __pyx_L48:; /* "src/llfuse/handlers.pxi":592 * fuse_getxattr(req, ino, cname, size) * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":617 * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_ */ static void __pyx_f_6llfuse_4capi_fuse_listxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, size_t __pyx_v_size) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_listxattr", 0); /* "src/llfuse/handlers.pxi":621 * cdef ssize_t len_ * cdef char *cbuf * try: # <<<<<<<<<<<<<< * with lock: * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":623 * try: * with lock: * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' # <<<<<<<<<<<<<< * * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_listxattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyBytes_Join(__pyx_kp_b__28, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyNumber_Add(__pyx_t_6, __pyx_kp_b__28); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__29, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":625 * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * * if len_ == 1: # No attributes */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_16 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":627 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * * if len_ == 1: # No attributes # <<<<<<<<<<<<<< * len_ = 0 * */ __pyx_t_15 = ((__pyx_v_len_ == 1) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":628 * * if len_ == 1: # No attributes * len_ = 0 # <<<<<<<<<<<<<< * * if size == 0: */ __pyx_v_len_ = 0; goto __pyx_L29; } __pyx_L29:; /* "src/llfuse/handlers.pxi":630 * len_ = 0 * * if size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: */ __pyx_t_15 = ((__pyx_v_size == 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":631 * * if size == 0: * ret = fuse_reply_xattr(req, len_) # <<<<<<<<<<<<<< * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_v_ret = fuse_reply_xattr(__pyx_v_req, __pyx_v_len_); goto __pyx_L30; } /* "src/llfuse/handlers.pxi":632 * if size == 0: * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * else: */ __pyx_t_15 = ((((size_t)__pyx_v_len_) <= __pyx_v_size) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":633 * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, errno.ERANGE) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); goto __pyx_L30; } /*else*/ { /* "src/llfuse/handlers.pxi":635 * ret = fuse_reply_buf(req, cbuf, len_) * else: * ret = fuse_reply_err(req, errno.ERANGE) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, ERANGE); } __pyx_L30:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":636 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":637 * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('listxattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":636 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L37; } /*exception exit:*/{ __pyx_L36_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L37:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":638 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('listxattr', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":639 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('listxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_listxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":638 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('listxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":641 * ret = handle_exc('listxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":642 * * if ret != 0: * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_listxattr_fuse_reply__faile); __Pyx_GIVEREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L49; } __pyx_L49:; /* "src/llfuse/handlers.pxi":617 * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_ */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":644 * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: # <<<<<<<<<<<<<< * cdef int ret * try: */ static void __pyx_f_6llfuse_4capi_fuse_removexattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname) { int __pyx_v_ret; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_removexattr", 0); /* "src/llfuse/handlers.pxi":646 * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: * cdef int ret * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":647 * cdef int ret * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * operations.removexattr(ino, name) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":649 * name = PyBytes_FromString(cname) * with lock: * operations.removexattr(ino, name) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_removexattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_13); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_13 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__30, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":650 * with lock: * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; /* "src/llfuse/handlers.pxi":651 * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":652 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('removexattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":651 * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":653 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('removexattr', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":654 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('removexattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_removexattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":653 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('removexattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":656 * ret = handle_exc('removexattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":657 * * if ret != 0: * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_12, __pyx_kp_u_fuse_removexattr_fuse_reply__fai); __Pyx_GIVEREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":644 * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: # <<<<<<<<<<<<<< * cdef int ret * try: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":659 * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_access(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, int __pyx_v_mask) { int __pyx_v_ret; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_allowed = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_access", 0); /* "src/llfuse/handlers.pxi":662 * cdef int ret * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":663 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * allowed = operations.access(ino, mask, ctx) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":665 * ctx = get_request_context(req) * with lock: * allowed = operations.access(ino, mask, ctx) # <<<<<<<<<<<<<< * if allowed: * ret = fuse_reply_err(req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_access); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_mask); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_allowed = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__31, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":666 * with lock: * allowed = operations.access(ino, mask, ctx) * if allowed: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * else: */ if (unlikely(!__pyx_v_allowed)) { __Pyx_RaiseUnboundLocalError("allowed"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_allowed); if (unlikely(__pyx_t_17 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":667 * allowed = operations.access(ino, mask, ctx) * if allowed: * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, EPERM) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); goto __pyx_L29; } /*else*/ { /* "src/llfuse/handlers.pxi":669 * ret = fuse_reply_err(req, 0) * else: * ret = fuse_reply_err(req, EPERM) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, EPERM); } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":670 * else: * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":671 * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('access', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":670 * else: * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":672 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('access', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":673 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('access', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_access, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":672 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('access', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L47; } __pyx_L47:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":675 * ret = handle_exc('access', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":676 * * if ret != 0: * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_access_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L48; } __pyx_L48:; /* "src/llfuse/handlers.pxi":659 * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_allowed); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":679 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *cname, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_create(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_cname, mode_t __pyx_v_mode, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *(*__pyx_t_16)(PyObject *); uint64_t __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; int __pyx_t_22; char const *__pyx_t_23; PyObject *__pyx_t_24 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_create", 0); /* "src/llfuse/handlers.pxi":684 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * name = PyBytes_FromString(cname) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":685 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":686 * try: * ctx = get_request_context(req) * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":688 * name = PyBytes_FromString(cname) * with lock: * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) # <<<<<<<<<<<<<< * * # Cached file data does not need to be invalidated. */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_create); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_fi->flags); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(5+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 4+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { PyObject* sequence = __pyx_t_4; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_6 = PyList_GET_ITEM(sequence, 0); __pyx_t_15 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_15); #else __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); #endif __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { Py_ssize_t index = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_16 = Py_TYPE(__pyx_t_12)->tp_iternext; index = 0; __pyx_t_6 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_6)) goto __pyx_L25_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); index = 1; __pyx_t_15 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_15)) goto __pyx_L25_unpacking_failed; __Pyx_GOTREF(__pyx_t_15); if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_12), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __pyx_t_16 = NULL; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L26_unpacking_done; __pyx_L25_unpacking_failed:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_16 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __pyx_L26_unpacking_done:; } __pyx_t_17 = __Pyx_PyInt_As_uint64_t(__pyx_t_6); if (unlikely((__pyx_t_17 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_fi->fh = __pyx_t_17; __pyx_v_attr = __pyx_t_15; __pyx_t_15 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_15, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_15, __pyx_t_6); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_18); __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_18); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; if (__pyx_t_19 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_20 = ((!(__pyx_t_19 != 0)) != 0); if (__pyx_t_20) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_15, __pyx_t_6); __pyx_t_4 = 0; __pyx_t_15 = 0; __pyx_t_6 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__32, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L30; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L30:; } /* "src/llfuse/handlers.pxi":692 * # Cached file data does not need to be invalidated. * # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ * fi.keep_cache = 1 # <<<<<<<<<<<<<< * * fill_entry_param(attr, &entry) */ __pyx_v_fi->keep_cache = 1; /* "src/llfuse/handlers.pxi":694 * fi.keep_cache = 1 * * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_6 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":695 * * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_create(__pyx_v_req, (&__pyx_v_entry), __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":696 * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_21 = PyErr_ExceptionMatches(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_15, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_15); __pyx_v_e = __pyx_t_15; /*try:*/ { /* "src/llfuse/handlers.pxi":697 * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('create', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_21 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_21 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_21); } /* "src/llfuse/handlers.pxi":696 * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L37; } /*exception exit:*/{ __pyx_L36_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_18 = 0; __pyx_t_24 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_18, &__pyx_t_24); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_24); __pyx_t_21 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_23 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_18, __pyx_t_24); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_18 = 0; __pyx_t_24 = 0; __pyx_lineno = __pyx_t_21; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_23; goto __pyx_L5_except_error; } __pyx_L37:; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":698 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('create', e, req) * */ __pyx_t_22 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_22) { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_15, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_15); __pyx_v_e = __pyx_t_15; /*try:*/ { /* "src/llfuse/handlers.pxi":699 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('create', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_create, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":698 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('create', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":701 * ret = handle_exc('create', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) */ __pyx_t_20 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/llfuse/handlers.pxi":702 * * if ret != 0: * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_15); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_create_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_15); __Pyx_GIVEREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L49; } __pyx_L49:; /* "src/llfuse/handlers.pxi":679 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *cname, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/misc.pxi":13 * ''' * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): # <<<<<<<<<<<<<< * entry.ino = attr.st_ino * entry.generation = attr.generation */ static PyObject *__pyx_f_6llfuse_4capi_fill_entry_param(PyObject *__pyx_v_attr, struct fuse_entry_param *__pyx_v_entry) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; fuse_ino_t __pyx_t_2; unsigned long __pyx_t_3; double __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_entry_param", 0); /* "src/llfuse/misc.pxi":14 * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): * entry.ino = attr.st_ino # <<<<<<<<<<<<<< * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ino); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->ino = __pyx_t_2; /* "src/llfuse/misc.pxi":15 * cdef object fill_entry_param(object attr, fuse_entry_param* entry): * entry.ino = attr.st_ino * entry.generation = attr.generation # <<<<<<<<<<<<<< * entry.entry_timeout = attr.entry_timeout * entry.attr_timeout = attr.attr_timeout */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_generation); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_unsigned_long(__pyx_t_1); if (unlikely((__pyx_t_3 == (unsigned long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->generation = __pyx_t_3; /* "src/llfuse/misc.pxi":16 * entry.ino = attr.st_ino * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout # <<<<<<<<<<<<<< * entry.attr_timeout = attr.attr_timeout * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_entry_timeout); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->entry_timeout = __pyx_t_4; /* "src/llfuse/misc.pxi":17 * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout * entry.attr_timeout = attr.attr_timeout # <<<<<<<<<<<<<< * * fill_c_stat(attr, &entry.attr) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->attr_timeout = __pyx_t_4; /* "src/llfuse/misc.pxi":19 * entry.attr_timeout = attr.attr_timeout * * fill_c_stat(attr, &entry.attr) # <<<<<<<<<<<<<< * * cdef object fill_c_stat(object attr, c_stat* stat): */ __pyx_t_1 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_entry->attr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 19; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":13 * ''' * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): # <<<<<<<<<<<<<< * entry.ino = attr.st_ino * entry.generation = attr.generation */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.fill_entry_param", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":21 * fill_c_stat(attr, &entry.attr) * * cdef object fill_c_stat(object attr, c_stat* stat): # <<<<<<<<<<<<<< * * # Under OS-X, c_stat has an additional st_flags field. The memset */ static PyObject *__pyx_f_6llfuse_4capi_fill_c_stat(PyObject *__pyx_v_attr, struct stat *__pyx_v_stat) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; ino_t __pyx_t_2; mode_t __pyx_t_3; nlink_t __pyx_t_4; uid_t __pyx_t_5; gid_t __pyx_t_6; dev_t __pyx_t_7; off_t __pyx_t_8; blksize_t __pyx_t_9; blkcnt_t __pyx_t_10; int __pyx_t_11; int __pyx_t_12; PyObject *__pyx_t_13 = NULL; time_t __pyx_t_14; long __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_c_stat", 0); /* "src/llfuse/misc.pxi":27 * # platform check (although, admittedly, this explanatory comment * # make take even more space than the check would have taken). * string.memset(stat, 0, sizeof(c_stat)) # <<<<<<<<<<<<<< * * stat.st_ino = attr.st_ino */ memset(__pyx_v_stat, 0, (sizeof(struct stat))); /* "src/llfuse/misc.pxi":29 * string.memset(stat, 0, sizeof(c_stat)) * * stat.st_ino = attr.st_ino # <<<<<<<<<<<<<< * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ino); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_ino_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_ino = __pyx_t_2; /* "src/llfuse/misc.pxi":30 * * stat.st_ino = attr.st_ino * stat.st_mode = attr.st_mode # <<<<<<<<<<<<<< * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_mode_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (mode_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_mode = __pyx_t_3; /* "src/llfuse/misc.pxi":31 * stat.st_ino = attr.st_ino * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink # <<<<<<<<<<<<<< * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_nlink); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_nlink_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (nlink_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_nlink = __pyx_t_4; /* "src/llfuse/misc.pxi":32 * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid # <<<<<<<<<<<<<< * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyInt_As_uid_t(__pyx_t_1); if (unlikely((__pyx_t_5 == (uid_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_uid = __pyx_t_5; /* "src/llfuse/misc.pxi":33 * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid # <<<<<<<<<<<<<< * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_gid_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (gid_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_gid = __pyx_t_6; /* "src/llfuse/misc.pxi":34 * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev # <<<<<<<<<<<<<< * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_rdev); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyInt_As_dev_t(__pyx_t_1); if (unlikely((__pyx_t_7 == (dev_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_rdev = __pyx_t_7; /* "src/llfuse/misc.pxi":35 * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size # <<<<<<<<<<<<<< * stat.st_blksize = attr.st_blksize * stat.st_blocks = attr.st_blocks */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_size); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyInt_As_off_t(__pyx_t_1); if (unlikely((__pyx_t_8 == (off_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_size = __pyx_t_8; /* "src/llfuse/misc.pxi":36 * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize # <<<<<<<<<<<<<< * stat.st_blocks = attr.st_blocks * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_blksize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyInt_As_blksize_t(__pyx_t_1); if (unlikely((__pyx_t_9 == (blksize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_blksize = __pyx_t_9; /* "src/llfuse/misc.pxi":37 * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize * stat.st_blocks = attr.st_blocks # <<<<<<<<<<<<<< * * if attr.st_atime_ns is not None: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_blocks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyInt_As_blkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_10 == (blkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_blocks = __pyx_t_10; /* "src/llfuse/misc.pxi":39 * stat.st_blocks = attr.st_blocks * * if attr.st_atime_ns is not None: # <<<<<<<<<<<<<< * stat.st_atime = attr.st_atime_ns / 10**9 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_12 = (__pyx_t_11 != 0); if (__pyx_t_12) { /* "src/llfuse/misc.pxi":40 * * if attr.st_atime_ns is not None: * stat.st_atime = attr.st_atime_ns / 10**9 # <<<<<<<<<<<<<< * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) * else: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_int_1000000000); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_13); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_stat->st_atime = __pyx_t_14; /* "src/llfuse/misc.pxi":41 * if attr.st_atime_ns is not None: * stat.st_atime = attr.st_atime_ns / 10**9 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_atime = attr.st_atime */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_1 = PyNumber_Remainder(__pyx_t_13, __pyx_int_1000000000); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_ATIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":43 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) * else: * stat.st_atime = attr.st_atime # <<<<<<<<<<<<<< * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_1); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_atime = __pyx_t_14; /* "src/llfuse/misc.pxi":44 * else: * stat.st_atime = attr.st_atime * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) # <<<<<<<<<<<<<< * * if attr.st_ctime_ns is not None: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_atime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = PyNumber_Subtract(__pyx_t_1, __pyx_t_13); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = PyNumber_Multiply(__pyx_t_16, __pyx_float_1e9); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_13); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; SET_ATIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L3:; /* "src/llfuse/misc.pxi":46 * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) * * if attr.st_ctime_ns is not None: # <<<<<<<<<<<<<< * stat.st_ctime = attr.st_ctime_ns / 10**9 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = (__pyx_t_13 != Py_None); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_11 = (__pyx_t_12 != 0); if (__pyx_t_11) { /* "src/llfuse/misc.pxi":47 * * if attr.st_ctime_ns is not None: * stat.st_ctime = attr.st_ctime_ns / 10**9 # <<<<<<<<<<<<<< * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) * else: */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = __Pyx_PyNumber_Divide(__pyx_t_13, __pyx_int_1000000000); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_16); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_v_stat->st_ctime = __pyx_t_14; /* "src/llfuse/misc.pxi":48 * if attr.st_ctime_ns is not None: * stat.st_ctime = attr.st_ctime_ns / 10**9 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_ctime = attr.st_ctime */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyNumber_Remainder(__pyx_t_16, __pyx_int_1000000000); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_13); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; SET_CTIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L4; } /*else*/ { /* "src/llfuse/misc.pxi":50 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) * else: * stat.st_ctime = attr.st_ctime # <<<<<<<<<<<<<< * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) * */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_13); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_stat->st_ctime = __pyx_t_14; /* "src/llfuse/misc.pxi":51 * else: * stat.st_ctime = attr.st_ctime * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) # <<<<<<<<<<<<<< * * if attr.st_mtime_ns is not None: */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_ctime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = PyNumber_Subtract(__pyx_t_13, __pyx_t_16); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = PyNumber_Multiply(__pyx_t_1, __pyx_float_1e9); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_16); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; SET_CTIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L4:; /* "src/llfuse/misc.pxi":53 * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) * * if attr.st_mtime_ns is not None: # <<<<<<<<<<<<<< * stat.st_mtime = attr.st_mtime_ns / 10**9 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 53; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_11 = (__pyx_t_16 != Py_None); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_12 = (__pyx_t_11 != 0); if (__pyx_t_12) { /* "src/llfuse/misc.pxi":54 * * if attr.st_mtime_ns is not None: * stat.st_mtime = attr.st_mtime_ns / 10**9 # <<<<<<<<<<<<<< * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) * else: */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_16, __pyx_int_1000000000); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_1); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_mtime = __pyx_t_14; /* "src/llfuse/misc.pxi":55 * if attr.st_mtime_ns is not None: * stat.st_mtime = attr.st_mtime_ns / 10**9 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_mtime = attr.st_mtime */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_16 = PyNumber_Remainder(__pyx_t_1, __pyx_int_1000000000); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_16); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; SET_MTIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L5; } /*else*/ { /* "src/llfuse/misc.pxi":57 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) * else: * stat.st_mtime = attr.st_mtime # <<<<<<<<<<<<<< * SET_MTIME_NS(stat, (attr.st_mtime - stat.st_mtime) * 1e9) * */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_16); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_v_stat->st_mtime = __pyx_t_14; /* "src/llfuse/misc.pxi":58 * else: * stat.st_mtime = attr.st_mtime * SET_MTIME_NS(stat, (attr.st_mtime - stat.st_mtime) * 1e9) # <<<<<<<<<<<<<< * * */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_mtime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyNumber_Subtract(__pyx_t_16, __pyx_t_1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyNumber_Multiply(__pyx_t_13, __pyx_float_1e9); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_MTIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L5:; /* "src/llfuse/misc.pxi":21 * fill_c_stat(attr, &entry.attr) * * cdef object fill_c_stat(object attr, c_stat* stat): # <<<<<<<<<<<<<< * * # Under OS-X, c_stat has an additional st_flags field. The memset */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_16); __Pyx_AddTraceback("llfuse.capi.fill_c_stat", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":61 * * * cdef object fill_statvfs(object attr, statvfs* stat): # <<<<<<<<<<<<<< * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize */ static PyObject *__pyx_f_6llfuse_4capi_fill_statvfs(PyObject *__pyx_v_attr, struct statvfs *__pyx_v_stat) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; fsblkcnt_t __pyx_t_3; fsfilcnt_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_statvfs", 0); /* "src/llfuse/misc.pxi":62 * * cdef object fill_statvfs(object attr, statvfs* stat): * stat.f_bsize = attr.f_bsize # <<<<<<<<<<<<<< * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 62; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 62; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bsize = __pyx_t_2; /* "src/llfuse/misc.pxi":63 * cdef object fill_statvfs(object attr, statvfs* stat): * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize # <<<<<<<<<<<<<< * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_frsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_frsize = __pyx_t_2; /* "src/llfuse/misc.pxi":64 * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks # <<<<<<<<<<<<<< * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_blocks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 64; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 64; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_blocks = __pyx_t_3; /* "src/llfuse/misc.pxi":65 * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree # <<<<<<<<<<<<<< * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bfree); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 65; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 65; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bfree = __pyx_t_3; /* "src/llfuse/misc.pxi":66 * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail # <<<<<<<<<<<<<< * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bavail); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bavail = __pyx_t_3; /* "src/llfuse/misc.pxi":67 * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files # <<<<<<<<<<<<<< * stat.f_ffree = attr.f_ffree * stat.f_favail = attr.f_favail */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_files); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 67; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 67; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_files = __pyx_t_4; /* "src/llfuse/misc.pxi":68 * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree # <<<<<<<<<<<<<< * stat.f_favail = attr.f_favail * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_ffree); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 68; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 68; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_ffree = __pyx_t_4; /* "src/llfuse/misc.pxi":69 * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree * stat.f_favail = attr.f_favail # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_favail); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_favail = __pyx_t_4; /* "src/llfuse/misc.pxi":61 * * * cdef object fill_statvfs(object attr, statvfs* stat): # <<<<<<<<<<<<<< * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.fill_statvfs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":72 * * * cdef int handle_exc(char* fn, object e, fuse_req_t req): # <<<<<<<<<<<<<< * '''Try to call fuse_reply_err and terminate main loop''' * */ static int __pyx_f_6llfuse_4capi_handle_exc(CYTHON_UNUSED char *__pyx_v_fn, CYTHON_UNUSED PyObject *__pyx_v_e, fuse_req_t __pyx_v_req) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("handle_exc", 0); /* "src/llfuse/misc.pxi":77 * global exc_info * * if not exc_info: # <<<<<<<<<<<<<< * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":78 * * if not exc_info: * exc_info = sys.exc_info() # <<<<<<<<<<<<<< * log.debug('handler raised exception, sending SIGTERM to self.') * kill(getpid(), SIGTERM) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_4) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":79 * if not exc_info: * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') # <<<<<<<<<<<<<< * kill(getpid(), SIGTERM) * else: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":80 * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') * kill(getpid(), SIGTERM) # <<<<<<<<<<<<<< * else: * log.exception('Exception after kill:') */ kill(getpid(), SIGTERM); goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":82 * kill(getpid(), SIGTERM) * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * if req is NULL: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_exception); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "src/llfuse/misc.pxi":84 * log.exception('Exception after kill:') * * if req is NULL: # <<<<<<<<<<<<<< * return 0 * else: */ __pyx_t_2 = ((__pyx_v_req == NULL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":85 * * if req is NULL: * return 0 # <<<<<<<<<<<<<< * else: * return fuse_reply_err(req, errno.EIO) */ __pyx_r = 0; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":87 * return 0 * else: * return fuse_reply_err(req, errno.EIO) # <<<<<<<<<<<<<< * * cdef object get_request_context(fuse_req_t req): */ __pyx_r = fuse_reply_err(__pyx_v_req, EIO); goto __pyx_L0; } /* "src/llfuse/misc.pxi":72 * * * cdef int handle_exc(char* fn, object e, fuse_req_t req): # <<<<<<<<<<<<<< * '''Try to call fuse_reply_err and terminate main loop''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("llfuse.capi.handle_exc", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":89 * return fuse_reply_err(req, errno.EIO) * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ static PyObject *__pyx_f_6llfuse_4capi_get_request_context(fuse_req_t __pyx_v_req) { const struct fuse_ctx *__pyx_v_context; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_request_context", 0); /* "src/llfuse/misc.pxi":94 * cdef const_fuse_ctx* context * * context = fuse_req_ctx(req) # <<<<<<<<<<<<<< * ctx = RequestContext() * ctx.pid = context.pid */ __pyx_v_context = fuse_req_ctx(__pyx_v_req); /* "src/llfuse/misc.pxi":95 * * context = fuse_req_ctx(req) * ctx = RequestContext() # <<<<<<<<<<<<<< * ctx.pid = context.pid * ctx.uid = context.uid */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_RequestContext); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":96 * context = fuse_req_ctx(req) * ctx = RequestContext() * ctx.pid = context.pid # <<<<<<<<<<<<<< * ctx.uid = context.uid * ctx.gid = context.gid */ __pyx_t_1 = __Pyx_PyInt_From_pid_t(__pyx_v_context->pid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_pid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":97 * ctx = RequestContext() * ctx.pid = context.pid * ctx.uid = context.uid # <<<<<<<<<<<<<< * ctx.gid = context.gid * ctx.umask = context.umask */ __pyx_t_1 = __Pyx_PyInt_From_uid_t(__pyx_v_context->uid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 97; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_uid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 97; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":98 * ctx.pid = context.pid * ctx.uid = context.uid * ctx.gid = context.gid # <<<<<<<<<<<<<< * ctx.umask = context.umask * */ __pyx_t_1 = __Pyx_PyInt_From_gid_t(__pyx_v_context->gid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_gid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":99 * ctx.uid = context.uid * ctx.gid = context.gid * ctx.umask = context.umask # <<<<<<<<<<<<<< * * return ctx */ __pyx_t_1 = __Pyx_PyInt_From_mode_t(__pyx_v_context->umask); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_umask, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":101 * ctx.umask = context.umask * * return ctx # <<<<<<<<<<<<<< * * cdef void init_fuse_ops(): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ctx); __pyx_r = __pyx_v_ctx; goto __pyx_L0; /* "src/llfuse/misc.pxi":89 * return fuse_reply_err(req, errno.EIO) * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.get_request_context", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":103 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ static void __pyx_f_6llfuse_4capi_init_fuse_ops(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init_fuse_ops", 0); /* "src/llfuse/misc.pxi":106 * '''Initialize fuse_lowlevel_ops structure''' * * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) # <<<<<<<<<<<<<< * * fuse_ops.init = fuse_init */ memset((&__pyx_v_6llfuse_4capi_fuse_ops), 0, (sizeof(struct fuse_lowlevel_ops))); /* "src/llfuse/misc.pxi":108 * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) * * fuse_ops.init = fuse_init # <<<<<<<<<<<<<< * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup */ __pyx_v_6llfuse_4capi_fuse_ops.init = __pyx_f_6llfuse_4capi_fuse_init; /* "src/llfuse/misc.pxi":109 * * fuse_ops.init = fuse_init * fuse_ops.destroy = fuse_destroy # <<<<<<<<<<<<<< * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget */ __pyx_v_6llfuse_4capi_fuse_ops.destroy = __pyx_f_6llfuse_4capi_fuse_destroy; /* "src/llfuse/misc.pxi":110 * fuse_ops.init = fuse_init * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup # <<<<<<<<<<<<<< * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr */ __pyx_v_6llfuse_4capi_fuse_ops.lookup = __pyx_f_6llfuse_4capi_fuse_lookup; /* "src/llfuse/misc.pxi":111 * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget # <<<<<<<<<<<<<< * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr */ __pyx_v_6llfuse_4capi_fuse_ops.forget = __pyx_f_6llfuse_4capi_fuse_forget; /* "src/llfuse/misc.pxi":112 * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr # <<<<<<<<<<<<<< * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink */ __pyx_v_6llfuse_4capi_fuse_ops.getattr = __pyx_f_6llfuse_4capi_fuse_getattr; /* "src/llfuse/misc.pxi":113 * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr # <<<<<<<<<<<<<< * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod */ __pyx_v_6llfuse_4capi_fuse_ops.setattr = __pyx_f_6llfuse_4capi_fuse_setattr; /* "src/llfuse/misc.pxi":114 * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink # <<<<<<<<<<<<<< * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir */ __pyx_v_6llfuse_4capi_fuse_ops.readlink = __pyx_f_6llfuse_4capi_fuse_readlink; /* "src/llfuse/misc.pxi":115 * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod # <<<<<<<<<<<<<< * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink */ __pyx_v_6llfuse_4capi_fuse_ops.mknod = __pyx_f_6llfuse_4capi_fuse_mknod; /* "src/llfuse/misc.pxi":116 * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir # <<<<<<<<<<<<<< * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir */ __pyx_v_6llfuse_4capi_fuse_ops.mkdir = __pyx_f_6llfuse_4capi_fuse_mkdir; /* "src/llfuse/misc.pxi":117 * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink # <<<<<<<<<<<<<< * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink */ __pyx_v_6llfuse_4capi_fuse_ops.unlink = __pyx_f_6llfuse_4capi_fuse_unlink; /* "src/llfuse/misc.pxi":118 * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir # <<<<<<<<<<<<<< * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename */ __pyx_v_6llfuse_4capi_fuse_ops.rmdir = __pyx_f_6llfuse_4capi_fuse_rmdir; /* "src/llfuse/misc.pxi":119 * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink # <<<<<<<<<<<<<< * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link */ __pyx_v_6llfuse_4capi_fuse_ops.symlink = __pyx_f_6llfuse_4capi_fuse_symlink; /* "src/llfuse/misc.pxi":120 * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename # <<<<<<<<<<<<<< * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open */ __pyx_v_6llfuse_4capi_fuse_ops.rename = __pyx_f_6llfuse_4capi_fuse_rename; /* "src/llfuse/misc.pxi":121 * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link # <<<<<<<<<<<<<< * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read */ __pyx_v_6llfuse_4capi_fuse_ops.link = __pyx_f_6llfuse_4capi_fuse_link; /* "src/llfuse/misc.pxi":122 * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open # <<<<<<<<<<<<<< * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write */ __pyx_v_6llfuse_4capi_fuse_ops.open = __pyx_f_6llfuse_4capi_fuse_open; /* "src/llfuse/misc.pxi":123 * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read # <<<<<<<<<<<<<< * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush */ __pyx_v_6llfuse_4capi_fuse_ops.read = __pyx_f_6llfuse_4capi_fuse_read; /* "src/llfuse/misc.pxi":124 * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write # <<<<<<<<<<<<<< * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release */ __pyx_v_6llfuse_4capi_fuse_ops.write = __pyx_f_6llfuse_4capi_fuse_write; /* "src/llfuse/misc.pxi":125 * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush # <<<<<<<<<<<<<< * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync */ __pyx_v_6llfuse_4capi_fuse_ops.flush = __pyx_f_6llfuse_4capi_fuse_flush; /* "src/llfuse/misc.pxi":126 * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release # <<<<<<<<<<<<<< * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir */ __pyx_v_6llfuse_4capi_fuse_ops.release = __pyx_f_6llfuse_4capi_fuse_release; /* "src/llfuse/misc.pxi":127 * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync # <<<<<<<<<<<<<< * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir */ __pyx_v_6llfuse_4capi_fuse_ops.fsync = __pyx_f_6llfuse_4capi_fuse_fsync; /* "src/llfuse/misc.pxi":128 * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir # <<<<<<<<<<<<<< * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir */ __pyx_v_6llfuse_4capi_fuse_ops.opendir = __pyx_f_6llfuse_4capi_fuse_opendir; /* "src/llfuse/misc.pxi":129 * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir # <<<<<<<<<<<<<< * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir */ __pyx_v_6llfuse_4capi_fuse_ops.readdir = __pyx_f_6llfuse_4capi_fuse_readdir; /* "src/llfuse/misc.pxi":130 * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir # <<<<<<<<<<<<<< * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs */ __pyx_v_6llfuse_4capi_fuse_ops.releasedir = __pyx_f_6llfuse_4capi_fuse_releasedir; /* "src/llfuse/misc.pxi":131 * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir # <<<<<<<<<<<<<< * fuse_ops.statfs = fuse_statfs * IF TARGET_PLATFORM == 'darwin': */ __pyx_v_6llfuse_4capi_fuse_ops.fsyncdir = __pyx_f_6llfuse_4capi_fuse_fsyncdir; /* "src/llfuse/misc.pxi":132 * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'darwin': * fuse_ops.setxattr = fuse_setxattr_darwin */ __pyx_v_6llfuse_4capi_fuse_ops.statfs = __pyx_f_6llfuse_4capi_fuse_statfs; /* "src/llfuse/misc.pxi":137 * fuse_ops.getxattr = fuse_getxattr_darwin * ELSE: * fuse_ops.setxattr = fuse_setxattr # <<<<<<<<<<<<<< * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr */ __pyx_v_6llfuse_4capi_fuse_ops.setxattr = __pyx_f_6llfuse_4capi_fuse_setxattr; /* "src/llfuse/misc.pxi":138 * ELSE: * fuse_ops.setxattr = fuse_setxattr * fuse_ops.getxattr = fuse_getxattr # <<<<<<<<<<<<<< * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr */ __pyx_v_6llfuse_4capi_fuse_ops.getxattr = __pyx_f_6llfuse_4capi_fuse_getxattr; /* "src/llfuse/misc.pxi":139 * fuse_ops.setxattr = fuse_setxattr * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr # <<<<<<<<<<<<<< * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access */ __pyx_v_6llfuse_4capi_fuse_ops.listxattr = __pyx_f_6llfuse_4capi_fuse_listxattr; /* "src/llfuse/misc.pxi":140 * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr # <<<<<<<<<<<<<< * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create */ __pyx_v_6llfuse_4capi_fuse_ops.removexattr = __pyx_f_6llfuse_4capi_fuse_removexattr; /* "src/llfuse/misc.pxi":141 * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access # <<<<<<<<<<<<<< * fuse_ops.create = fuse_create * */ __pyx_v_6llfuse_4capi_fuse_ops.access = __pyx_f_6llfuse_4capi_fuse_access; /* "src/llfuse/misc.pxi":142 * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create # <<<<<<<<<<<<<< * * cdef make_fuse_args(list args, fuse_args* f_args): */ __pyx_v_6llfuse_4capi_fuse_ops.create = __pyx_f_6llfuse_4capi_fuse_create; /* "src/llfuse/misc.pxi":103 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "src/llfuse/misc.pxi":144 * fuse_ops.create = fuse_create * * cdef make_fuse_args(list args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ static PyObject *__pyx_f_6llfuse_4capi_make_fuse_args(PyObject *__pyx_v_args, struct fuse_args *__pyx_v_f_args) { char *__pyx_v_arg; int __pyx_v_i; Py_ssize_t __pyx_v_size; PyObject *__pyx_v_args_new = NULL; PyObject *__pyx_v_el = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; int __pyx_t_13; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("make_fuse_args", 0); __Pyx_INCREF(__pyx_v_args); /* "src/llfuse/misc.pxi":149 * cdef ssize_t size * * args_new = [ b'Python-LLFUSE' ] # <<<<<<<<<<<<<< * for el in args: * if not isinstance(el, str_t): */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_b_Python_LLFUSE); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_kp_b_Python_LLFUSE); __Pyx_GIVEREF(__pyx_kp_b_Python_LLFUSE); __pyx_v_args_new = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":150 * * args_new = [ b'Python-LLFUSE' ] * for el in args: # <<<<<<<<<<<<<< * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') */ if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":151 * args_new = [ b'Python-LLFUSE' ] * for el in args: * if not isinstance(el, str_t): # <<<<<<<<<<<<<< * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_IsInstance(__pyx_v_el, __pyx_t_3); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":152 * for el in args: * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":153 * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') # <<<<<<<<<<<<<< * args_new.append(el.encode('us-ascii')) * args = args_new */ __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_kp_b_o); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 153; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":154 * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) # <<<<<<<<<<<<<< * args = args_new * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_el, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_t_7); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/misc.pxi":150 * * args_new = [ b'Python-LLFUSE' ] * for el in args: # <<<<<<<<<<<<<< * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":155 * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) * args = args_new # <<<<<<<<<<<<<< * * f_args.argc = len(args) */ __Pyx_INCREF(__pyx_v_args_new); __Pyx_DECREF_SET(__pyx_v_args, __pyx_v_args_new); /* "src/llfuse/misc.pxi":157 * args = args_new * * f_args.argc = len(args) # <<<<<<<<<<<<<< * if f_args.argc == 0: * f_args.argv = NULL */ __pyx_t_2 = PyList_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_f_args->argc = ((int)__pyx_t_2); /* "src/llfuse/misc.pxi":158 * * f_args.argc = len(args) * if f_args.argc == 0: # <<<<<<<<<<<<<< * f_args.argv = NULL * return */ __pyx_t_5 = ((__pyx_v_f_args->argc == 0) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":159 * f_args.argc = len(args) * if f_args.argc == 0: * f_args.argv = NULL # <<<<<<<<<<<<<< * return * */ __pyx_v_f_args->argv = NULL; /* "src/llfuse/misc.pxi":160 * if f_args.argc == 0: * f_args.argv = NULL * return # <<<<<<<<<<<<<< * * f_args.allocated = 1 */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":162 * return * * f_args.allocated = 1 # <<<<<<<<<<<<<< * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) * */ __pyx_v_f_args->allocated = 1; /* "src/llfuse/misc.pxi":163 * * f_args.allocated = 1 * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) # <<<<<<<<<<<<<< * * if f_args.argv is NULL: */ __pyx_v_f_args->argv = ((char **)calloc(__pyx_v_f_args->argc, (sizeof(char *)))); /* "src/llfuse/misc.pxi":165 * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) * * if f_args.argv is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_5 = ((__pyx_v_f_args->argv == NULL) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":166 * * if f_args.argv is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_8 = PyErr_NoMemory(); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L7; } __pyx_L7:; /* "src/llfuse/misc.pxi":168 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) */ { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/misc.pxi":169 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) */ __pyx_t_12 = 0; __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_7); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L8_error;} #else __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L8_error;} #endif __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_7); __pyx_t_7 = 0; __pyx_v_i = __pyx_t_12; __pyx_t_12 = (__pyx_t_12 + 1); /* "src/llfuse/misc.pxi":170 * try: * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) # <<<<<<<<<<<<<< * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * */ __pyx_t_13 = PyBytes_AsStringAndSize(__pyx_v_el, (&__pyx_v_arg), ((Py_ssize_t *)(&__pyx_v_size))); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 170; __pyx_clineno = __LINE__; goto __pyx_L8_error;} /* "src/llfuse/misc.pxi":171 * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) # <<<<<<<<<<<<<< * * if f_args.argv[i] is NULL: */ (__pyx_v_f_args->argv[__pyx_v_i]) = ((char *)malloc(((__pyx_v_size + 1) * (sizeof(char))))); /* "src/llfuse/misc.pxi":173 * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * * if f_args.argv[i] is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_5 = (((__pyx_v_f_args->argv[__pyx_v_i]) == NULL) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":174 * * if f_args.argv[i] is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * string.strncpy(f_args.argv[i], arg, size+1) */ __pyx_t_8 = PyErr_NoMemory(); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 174; __pyx_clineno = __LINE__; goto __pyx_L8_error;} goto __pyx_L18; } __pyx_L18:; /* "src/llfuse/misc.pxi":176 * cpython.exc.PyErr_NoMemory() * * string.strncpy(f_args.argv[i], arg, size+1) # <<<<<<<<<<<<<< * except: * for i in range(f_args.argc): */ strncpy((__pyx_v_f_args->argv[__pyx_v_i]), __pyx_v_arg, (__pyx_v_size + 1)); /* "src/llfuse/misc.pxi":169 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L15_try_end; __pyx_L8_error:; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":177 * * string.strncpy(f_args.argv[i], arg, size+1) * except: # <<<<<<<<<<<<<< * for i in range(f_args.argc): * # Freeing a NULL pointer (if this element has not been allocated */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 177; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_3); /* "src/llfuse/misc.pxi":178 * string.strncpy(f_args.argv[i], arg, size+1) * except: * for i in range(f_args.argc): # <<<<<<<<<<<<<< * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. */ __pyx_t_12 = __pyx_v_f_args->argc; for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_i = __pyx_t_13; /* "src/llfuse/misc.pxi":181 * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. * stdlib.free(f_args.argv[i]) # <<<<<<<<<<<<<< * stdlib.free(f_args.argv) * raise */ free((__pyx_v_f_args->argv[__pyx_v_i])); } /* "src/llfuse/misc.pxi":182 * # yet) is fine. * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) # <<<<<<<<<<<<<< * raise * */ free(__pyx_v_f_args->argv); /* "src/llfuse/misc.pxi":183 * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) * raise # <<<<<<<<<<<<<< * * cdef class Lock: */ __Pyx_GIVEREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ErrRestore(__pyx_t_1, __pyx_t_7, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 183; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;} } __pyx_L10_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L1_error; __pyx_L15_try_end:; } /* "src/llfuse/misc.pxi":144 * fuse_ops.create = fuse_create * * cdef make_fuse_args(list args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_args_new); __Pyx_XDECREF(__pyx_v_el); __Pyx_XDECREF(__pyx_v_args); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":191 * ''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* Python wrapper */ static int __pyx_pw_6llfuse_4capi_4Lock_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6llfuse_4capi_4Lock_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock___init__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6llfuse_4capi_4Lock___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/llfuse/misc.pxi":192 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":191 * ''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.Lock.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":195 * 'provided instance instead.') * * def acquire(self, timeout=None): # <<<<<<<<<<<<<< * '''Acquire global lock * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_3acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_2acquire[] = "Lock.acquire(self, timeout=None)\nAcquire global lock\n\n If *timeout* is not None, and the lock could not be acquired\n after waiting for *timeout* seconds, return False. Otherwise\n return True.\n "; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_3acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_timeout = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("acquire (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "acquire") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 195; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_timeout = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("acquire", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 195; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_2acquire(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_timeout); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_2acquire(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_timeout) { int __pyx_v_ret; int __pyx_v_timeout_c; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("acquire", 0); /* "src/llfuse/misc.pxi":206 * cdef int timeout_c * * if timeout is None: # <<<<<<<<<<<<<< * timeout_c = 0 * else: */ __pyx_t_1 = (__pyx_v_timeout == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":207 * * if timeout is None: * timeout_c = 0 # <<<<<<<<<<<<<< * else: * timeout_c = timeout */ __pyx_v_timeout_c = 0; goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":209 * timeout_c = 0 * else: * timeout_c = timeout # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_timeout); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 209; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_timeout_c = __pyx_t_3; } __pyx_L3:; /* "src/llfuse/misc.pxi":211 * timeout_c = timeout * * with nogil: # <<<<<<<<<<<<<< * ret = acquire(timeout_c) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":212 * * with nogil: * ret = acquire(timeout_c) # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = acquire(__pyx_v_timeout_c); } /* "src/llfuse/misc.pxi":211 * timeout_c = timeout * * with nogil: # <<<<<<<<<<<<<< * ret = acquire(timeout_c) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "src/llfuse/misc.pxi":214 * ret = acquire(timeout_c) * * if ret == 0: # <<<<<<<<<<<<<< * return True * elif ret == ETIMEDOUT and timeout != 0: */ __pyx_t_2 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":215 * * if ret == 0: * return True # <<<<<<<<<<<<<< * elif ret == ETIMEDOUT and timeout != 0: * return False */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; } /* "src/llfuse/misc.pxi":216 * if ret == 0: * return True * elif ret == ETIMEDOUT and timeout != 0: # <<<<<<<<<<<<<< * return False * elif ret == EDEADLK: */ __pyx_t_1 = ((__pyx_v_ret == ETIMEDOUT) != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L8_bool_binop_done; } __pyx_t_4 = PyObject_RichCompare(__pyx_v_timeout, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 216; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 216; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __pyx_t_1; __pyx_L8_bool_binop_done:; if (__pyx_t_2) { /* "src/llfuse/misc.pxi":217 * return True * elif ret == ETIMEDOUT and timeout != 0: * return False # <<<<<<<<<<<<<< * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; } /* "src/llfuse/misc.pxi":218 * elif ret == ETIMEDOUT and timeout != 0: * return False * elif ret == EDEADLK: # <<<<<<<<<<<<<< * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: */ __pyx_t_2 = ((__pyx_v_ret == EDEADLK) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":219 * return False * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":220 * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: # <<<<<<<<<<<<<< * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: */ __pyx_t_2 = ((__pyx_v_ret == EPROTO) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":221 * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":222 * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_2 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":223 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":225 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def release(self): */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (!__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":195 * 'provided instance instead.') * * def acquire(self, timeout=None): # <<<<<<<<<<<<<< * '''Acquire global lock * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.Lock.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":227 * raise RuntimeError(strerror(ret)) * * def release(self): # <<<<<<<<<<<<<< * '''Release global lock''' * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_5release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_4release[] = "Lock.release(self)\nRelease global lock"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_5release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("release (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_4release(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_4release(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { int __pyx_v_ret; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("release", 0); /* "src/llfuse/misc.pxi":231 * * cdef int ret * with nogil: # <<<<<<<<<<<<<< * ret = release() * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":232 * cdef int ret * with nogil: * ret = release() # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = release(); } /* "src/llfuse/misc.pxi":231 * * cdef int ret * with nogil: # <<<<<<<<<<<<<< * ret = release() * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "src/llfuse/misc.pxi":234 * ret = release() * * if ret == 0: # <<<<<<<<<<<<<< * return * elif ret == EPERM: */ __pyx_t_1 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":235 * * if ret == 0: * return # <<<<<<<<<<<<<< * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":236 * if ret == 0: * return * elif ret == EPERM: # <<<<<<<<<<<<<< * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: */ __pyx_t_1 = ((__pyx_v_ret == EPERM) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":237 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":238 * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_1 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":239 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":241 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def yield_(self, count=1): */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_5) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":227 * raise RuntimeError(strerror(ret)) * * def release(self): # <<<<<<<<<<<<<< * '''Release global lock''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.Lock.release", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":243 * raise RuntimeError(strerror(ret)) * * def yield_(self, count=1): # <<<<<<<<<<<<<< * '''Yield global lock to a different thread * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_7yield_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_6yield_[] = "Lock.yield_(self, count=1)\nYield global lock to a different thread\n\n The *count* argument may be used to yield the lock up to\n *count* times if there are still other threads waiting for the\n lock.\n "; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_7yield_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_count = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("yield_ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_count,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)__pyx_int_1); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_count); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "yield_") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_count = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("yield_", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.yield_", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_6yield_(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_count); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_6yield_(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_count) { int __pyx_v_ret; int __pyx_v_count_c; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("yield_", 0); /* "src/llfuse/misc.pxi":254 * cdef int count_c * * count_c = count # <<<<<<<<<<<<<< * with nogil: * ret = c_yield(count_c) */ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_count); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 254; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_count_c = __pyx_t_1; /* "src/llfuse/misc.pxi":255 * * count_c = count * with nogil: # <<<<<<<<<<<<<< * ret = c_yield(count_c) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":256 * count_c = count * with nogil: * ret = c_yield(count_c) # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = c_yield(__pyx_v_count_c); } /* "src/llfuse/misc.pxi":255 * * count_c = count * with nogil: # <<<<<<<<<<<<<< * ret = c_yield(count_c) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "src/llfuse/misc.pxi":258 * ret = c_yield(count_c) * * if ret == 0: # <<<<<<<<<<<<<< * return * elif ret == EPERM: */ __pyx_t_2 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":259 * * if ret == 0: * return # <<<<<<<<<<<<<< * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":260 * if ret == 0: * return * elif ret == EPERM: # <<<<<<<<<<<<<< * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: */ __pyx_t_2 = ((__pyx_v_ret == EPERM) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":261 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":262 * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: # <<<<<<<<<<<<<< * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: */ __pyx_t_2 = ((__pyx_v_ret == EPROTO) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":263 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":264 * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: # <<<<<<<<<<<<<< * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: */ __pyx_t_2 = ((__pyx_v_ret == ENOMSG) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":265 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":266 * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_2 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":267 * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":269 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def __enter__(self): */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (!__pyx_t_6) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":243 * raise RuntimeError(strerror(ret)) * * def yield_(self, count=1): # <<<<<<<<<<<<<< * '''Yield global lock to a different thread * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.Lock.yield_", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":271 * raise RuntimeError(strerror(ret)) * * def __enter__(self): # <<<<<<<<<<<<<< * self.acquire() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_8__enter__[] = "Lock.__enter__(self)"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_8__enter__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_8__enter__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__enter__", 0); /* "src/llfuse/misc.pxi":272 * * def __enter__(self): * self.acquire() # <<<<<<<<<<<<<< * * def __exit__(self, exc_type, exc_val, exc_tb): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_acquire); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":271 * raise RuntimeError(strerror(ret)) * * def __enter__(self): # <<<<<<<<<<<<<< * self.acquire() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.Lock.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":274 * self.acquire() * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.release() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_10__exit__[] = "Lock.__exit__(self, exc_type, exc_val, exc_tb)"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_exc_type = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_val = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_tb = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_exc_type,&__pyx_n_s_exc_val,&__pyx_n_s_exc_tb,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_val)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_tb)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__exit__") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_exc_type = values[0]; __pyx_v_exc_val = values[1]; __pyx_v_exc_tb = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_10__exit__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_exc_type, __pyx_v_exc_val, __pyx_v_exc_tb); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_10__exit__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 0); /* "src/llfuse/misc.pxi":275 * * def __exit__(self, exc_type, exc_val, exc_tb): * self.release() # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_release); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":274 * self.acquire() * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.release() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.Lock.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":281 * '''Context manager to execute code while the global lock is released''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* Python wrapper */ static int __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager___init__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6llfuse_4capi_13NoLockManager___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/llfuse/misc.pxi":282 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":281 * '''Context manager to execute code while the global lock is released''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":285 * 'provided instance instead.') * * def __enter__ (self): # <<<<<<<<<<<<<< * lock.release() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_13NoLockManager_2__enter__[] = "NoLockManager.__enter__(self)"; static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__enter__", 0); /* "src/llfuse/misc.pxi":286 * * def __enter__ (self): * lock.release() # <<<<<<<<<<<<<< * * def __exit__(self, *a): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_release); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":285 * 'provided instance instead.') * * def __enter__ (self): # <<<<<<<<<<<<<< * lock.release() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":288 * lock.release() * * def __exit__(self, *a): # <<<<<<<<<<<<<< * lock.acquire() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_13NoLockManager_4__exit__[] = "NoLockManager.__exit__(self, *a)"; static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_a = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__exit__", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_a = __pyx_args; __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self), __pyx_v_a); /* function exit code */ __Pyx_XDECREF(__pyx_v_a); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 0); /* "src/llfuse/misc.pxi":289 * * def __exit__(self, *a): * lock.acquire() # <<<<<<<<<<<<<< * * def _notify_loop(): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_acquire); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":288 * lock.release() * * def __exit__(self, *a): # <<<<<<<<<<<<<< * lock.acquire() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_1_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi__notify_loop[] = "_notify_loop()\nRead notifications from queue and send to FUSE kernel module"; static PyMethodDef __pyx_mdef_6llfuse_4capi_1_notify_loop = {"_notify_loop", (PyCFunction)__pyx_pw_6llfuse_4capi_1_notify_loop, METH_NOARGS, __pyx_doc_6llfuse_4capi__notify_loop}; static PyObject *__pyx_pw_6llfuse_4capi_1_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_notify_loop (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi__notify_loop(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi__notify_loop(CYTHON_UNUSED PyObject *__pyx_self) { Py_ssize_t __pyx_v_len_; fuse_ino_t __pyx_v_ino; char *__pyx_v_cname; PyObject *__pyx_v_req = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; fuse_ino_t __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_notify_loop", 0); /* "src/llfuse/misc.pxi":298 * cdef char *cname * * while True: # <<<<<<<<<<<<<< * req = _notify_queue.get() * if req is None: */ while (1) { /* "src/llfuse/misc.pxi":299 * * while True: * req = _notify_queue.get() # <<<<<<<<<<<<<< * if req is None: * return */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_req, __pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":300 * while True: * req = _notify_queue.get() * if req is None: # <<<<<<<<<<<<<< * return * */ __pyx_t_4 = (__pyx_v_req == Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":301 * req = _notify_queue.get() * if req is None: * return # <<<<<<<<<<<<<< * * if isinstance(req, inval_inode_req): */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":303 * return * * if isinstance(req, inval_inode_req): # <<<<<<<<<<<<<< * ino = req.inode * if req.attr_only: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_inode_req); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = PyObject_IsInstance(__pyx_v_req, __pyx_t_1); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = (__pyx_t_5 != 0); if (__pyx_t_4) { /* "src/llfuse/misc.pxi":304 * * if isinstance(req, inval_inode_req): * ino = req.inode # <<<<<<<<<<<<<< * if req.attr_only: * with nogil: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_inode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ino = __pyx_t_6; /* "src/llfuse/misc.pxi":305 * if isinstance(req, inval_inode_req): * ino = req.inode * if req.attr_only: # <<<<<<<<<<<<<< * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_attr_only); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_4) { /* "src/llfuse/misc.pxi":306 * ino = req.inode * if req.attr_only: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":307 * if req.attr_only: * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) # <<<<<<<<<<<<<< * else: * with nogil: */ fuse_lowlevel_notify_inval_inode(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, -1, 0); } /* "src/llfuse/misc.pxi":306 * ino = req.inode * if req.attr_only: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L12; } __pyx_L12:; } } goto __pyx_L7; } /*else*/ { /* "src/llfuse/misc.pxi":309 * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":310 * else: * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) # <<<<<<<<<<<<<< * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) */ fuse_lowlevel_notify_inval_inode(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, 0, 0); } /* "src/llfuse/misc.pxi":309 * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L17; } __pyx_L17:; } } } __pyx_L7:; goto __pyx_L6; } /* "src/llfuse/misc.pxi":311 * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_entry_req); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 311; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyObject_IsInstance(__pyx_v_req, __pyx_t_1); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 311; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":312 * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) # <<<<<<<<<<<<<< * ino = req.inode_p * with nogil: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = PyBytes_AsStringAndSize(__pyx_t_1, (&__pyx_v_cname), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":313 * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p # <<<<<<<<<<<<<< * with nogil: * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_inode_p); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ino = __pyx_t_6; /* "src/llfuse/misc.pxi":314 * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":315 * ino = req.inode_p * with nogil: * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) # <<<<<<<<<<<<<< * else: * raise RuntimeError("Weird request received: %r", req) */ fuse_lowlevel_notify_inval_entry(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, __pyx_v_cname, __pyx_v_len_); } /* "src/llfuse/misc.pxi":314 * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } goto __pyx_L6; } /*else*/ { /* "src/llfuse/misc.pxi":317 * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: * raise RuntimeError("Weird request received: %r", req) # <<<<<<<<<<<<<< * * cdef str2bytes(s): */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_u_Weird_request_received_r); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Weird_request_received_r); __Pyx_GIVEREF(__pyx_kp_u_Weird_request_received_r); __Pyx_INCREF(__pyx_v_req); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_req); __Pyx_GIVEREF(__pyx_v_req); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_L6:; } /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi._notify_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_req); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":319 * raise RuntimeError("Weird request received: %r", req) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes * */ static PyObject *__pyx_f_6llfuse_4capi_str2bytes(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("str2bytes", 0); /* "src/llfuse/misc.pxi":326 * ''' * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return s * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":327 * * if PY_MAJOR_VERSION < 3: * return s # <<<<<<<<<<<<<< * else: * return s.encode(fse, 'surrogateescape') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":329 * return s * else: * return s.encode(fse, 'surrogateescape') # <<<<<<<<<<<<<< * * cdef bytes2str(s): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_fse); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "src/llfuse/misc.pxi":319 * raise RuntimeError("Weird request received: %r", req) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":331 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str * */ static PyObject *__pyx_f_6llfuse_4capi_bytes2str(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bytes2str", 0); /* "src/llfuse/misc.pxi":338 * ''' * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return s * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":339 * * if PY_MAJOR_VERSION < 3: * return s # <<<<<<<<<<<<<< * else: * return s.decode(fse, 'surrogateescape') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":341 * return s * else: * return s.decode(fse, 'surrogateescape') # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_decode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_fse); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "src/llfuse/misc.pxi":331 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_3listdir(PyObject *__pyx_self, PyObject *__pyx_v_path); /*proto*/ static char __pyx_doc_6llfuse_4capi_2listdir[] = "listdir(path)\nLike `os.listdir`, but releases the GIL.\n\n This function returns an iterator over the directory entries in\n *path*. The returned values are of type :ref:`str\n ` in both Python 2.x and 3.x.\n\n In Python 2.x :class:`str` is equivalent to `bytes` so all names\n can be represented. In Python 3.x, surrogate escape coding (cf.\n `PEP 383 `_) is used for\n directory names that do not have a string representation.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_3listdir = {"listdir", (PyCFunction)__pyx_pw_6llfuse_4capi_3listdir, METH_O, __pyx_doc_6llfuse_4capi_2listdir}; static PyObject *__pyx_pw_6llfuse_4capi_3listdir(PyObject *__pyx_self, PyObject *__pyx_v_path) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("listdir (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_2listdir(__pyx_self, ((PyObject *)__pyx_v_path)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_2listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path) { DIR *__pyx_v_dirp; struct dirent __pyx_v_ent; struct dirent *__pyx_v_res; int __pyx_v_ret; char *__pyx_v_buf; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_names = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("listdir", 0); /* "src/llfuse/fuse_api.pxi":27 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":28 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef dirent.DIR* dirp */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":36 * cdef char* buf * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * buf = path_b * */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":37 * * path_b = str2bytes(path) * buf = path_b # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_buf = ((char *)__pyx_t_4); /* "src/llfuse/fuse_api.pxi":39 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = dirent.opendir(buf) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":40 * * with nogil: * dirp = dirent.opendir(buf) # <<<<<<<<<<<<<< * * if dirp == NULL: */ __pyx_v_dirp = opendir(__pyx_v_buf); } /* "src/llfuse/fuse_api.pxi":39 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = dirent.opendir(buf) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "src/llfuse/fuse_api.pxi":42 * dirp = dirent.opendir(buf) * * if dirp == NULL: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_dirp == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":43 * * if dirp == NULL: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * names = list() */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":45 * raise OSError(errno.errno, strerror(errno.errno), path) * * names = list() # <<<<<<<<<<<<<< * while True: * errno.errno = 0 */ __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_v_names = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; /* "src/llfuse/fuse_api.pxi":46 * * names = list() * while True: # <<<<<<<<<<<<<< * errno.errno = 0 * with nogil: */ while (1) { /* "src/llfuse/fuse_api.pxi":47 * names = list() * while True: * errno.errno = 0 # <<<<<<<<<<<<<< * with nogil: * ret = dirent.readdir_r(dirp, &ent, &res) */ errno = 0; /* "src/llfuse/fuse_api.pxi":48 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * ret = dirent.readdir_r(dirp, &ent, &res) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":49 * errno.errno = 0 * with nogil: * ret = dirent.readdir_r(dirp, &ent, &res) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = readdir_r(__pyx_v_dirp, (&__pyx_v_ent), (&__pyx_v_res)); } /* "src/llfuse/fuse_api.pxi":48 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * ret = dirent.readdir_r(dirp, &ent, &res) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L14; } __pyx_L14:; } } /* "src/llfuse/fuse_api.pxi":51 * ret = dirent.readdir_r(dirp, &ent, &res) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: */ __pyx_t_3 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":52 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * if res is NULL: * break */ __pyx_t_5 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":53 * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: # <<<<<<<<<<<<<< * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: */ __pyx_t_3 = ((__pyx_v_res == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":54 * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: * break # <<<<<<<<<<<<<< * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: * continue */ goto __pyx_L9_break; } /* "src/llfuse/fuse_api.pxi":55 * if res is NULL: * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: # <<<<<<<<<<<<<< * continue * */ __pyx_t_2 = ((strcmp(__pyx_v_ent.d_name, __pyx_k__49) == 0) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L18_bool_binop_done; } __pyx_t_2 = ((strcmp(__pyx_v_ent.d_name, __pyx_k__50) == 0) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L18_bool_binop_done:; if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":56 * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: * continue # <<<<<<<<<<<<<< * * names.append(bytes2str(PyBytes_FromString(ent.d_name))) */ goto __pyx_L8_continue; } /* "src/llfuse/fuse_api.pxi":58 * continue * * names.append(bytes2str(PyBytes_FromString(ent.d_name))) # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyBytes_FromString(__pyx_v_ent.d_name); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __pyx_f_6llfuse_4capi_bytes2str(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_names, __pyx_t_1); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_L8_continue:; } __pyx_L9_break:; /* "src/llfuse/fuse_api.pxi":60 * names.append(bytes2str(PyBytes_FromString(ent.d_name))) * * with nogil: # <<<<<<<<<<<<<< * dirent.closedir(dirp) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":61 * * with nogil: * dirent.closedir(dirp) # <<<<<<<<<<<<<< * * return names */ closedir(__pyx_v_dirp); } /* "src/llfuse/fuse_api.pxi":60 * names.append(bytes2str(PyBytes_FromString(ent.d_name))) * * with nogil: # <<<<<<<<<<<<<< * dirent.closedir(dirp) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } /* "src/llfuse/fuse_api.pxi":63 * dirent.closedir(dirp) * * return names # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_names); __pyx_r = __pyx_v_names; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("llfuse.capi.listdir", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_names); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_5setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4setxattr[] = "setxattr(path, name, bytes value, namespace=u'user')\nSet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. *value* has to be of type `bytes`.\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast the `os.setxattr` function from the standard library,\n the method provided by Python-LLFUSE is also available for non-Linux\n systems.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_5setxattr = {"setxattr", (PyCFunction)__pyx_pw_6llfuse_4capi_5setxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4setxattr}; static PyObject *__pyx_pw_6llfuse_4capi_5setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_value = 0; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_value,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 2); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setxattr") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; __pyx_v_value = ((PyObject*)values[2]); __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 1, "value", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_4setxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_value, __pyx_v_namespace); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cvalue; char *__pyx_v_cpath; char *__pyx_v_cname; int __pyx_v_cnamespace; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; char *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setxattr", 0); /* "src/llfuse/fuse_api.pxi":81 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":82 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":84 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str_t): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_name, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { /* "src/llfuse/fuse_api.pxi":85 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":87 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_1 = __pyx_v_namespace; __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":89 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef int ret */ __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 89; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); /* "src/llfuse/fuse_api.pxi":88 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":99 * IF TARGET_PLATFORM == 'freebsd': * cdef int cnamespace * if namespace == 'system': # <<<<<<<<<<<<<< * cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM * else: */ __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_namespace, __pyx_n_u_system, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":100 * cdef int cnamespace * if namespace == 'system': * cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM # <<<<<<<<<<<<<< * else: * cnamespace = xattr.EXTATTR_NAMESPACE_USER */ __pyx_v_cnamespace = EXTATTR_NAMESPACE_SYSTEM; goto __pyx_L8; } /*else*/ { /* "src/llfuse/fuse_api.pxi":102 * cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM * else: * cnamespace = xattr.EXTATTR_NAMESPACE_USER # <<<<<<<<<<<<<< * * path_b = str2bytes(path) */ __pyx_v_cnamespace = EXTATTR_NAMESPACE_USER; } __pyx_L8:; /* "src/llfuse/fuse_api.pxi":104 * cnamespace = xattr.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":105 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_name_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":106 * path_b = str2bytes(path) * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_5 = PyBytes_AsStringAndSize(__pyx_v_value, (&__pyx_v_cvalue), (&__pyx_v_len_)); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 106; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":107 * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cpath = ((char *)__pyx_t_6); /* "src/llfuse/fuse_api.pxi":108 * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_name_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cname = ((char *)__pyx_t_6); /* "src/llfuse/fuse_api.pxi":111 * * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_set_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":113 * with nogil: * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_set_file(cpath, cnamespace, cname, # <<<<<<<<<<<<<< * cvalue, len_) * ELSE: */ __pyx_v_ret = extattr_set_file(__pyx_v_cpath, __pyx_v_cnamespace, __pyx_v_cname, __pyx_v_cvalue, __pyx_v_len_); } /* "src/llfuse/fuse_api.pxi":111 * * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_set_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L11; } __pyx_L11:; } } /* "src/llfuse/fuse_api.pxi":118 * ret = xattr.setxattr(cpath, cname, cvalue, len_, 0) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":119 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_9) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("llfuse.capi.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_7getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_6getxattr[] = "getxattr(path, name, int size_guess=128, namespace=u'user')\nGet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. Returns a value of type `bytes`.\n\n If the caller knows the approximate size of the attribute value,\n it should be supplied in *size_guess*. If the guess turns out\n to be wrong, the system call has to be carried out three times\n (the first call will fail, the second determines the size and\n the third finally gets the value).\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast the `os.setxattr` function from the standard library,\n the method provided by Python-LLFUSE is also available for non-Linux\n systems.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_7getxattr = {"getxattr", (PyCFunction)__pyx_pw_6llfuse_4capi_7getxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_6getxattr}; static PyObject *__pyx_pw_6llfuse_4capi_7getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; int __pyx_v_size_guess; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_size_guess,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_size_guess); if (value) { values[2] = value; kw_args--; } } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getxattr") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; if (values[2]) { __pyx_v_size_guess = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_size_guess == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } else { __pyx_v_size_guess = ((int)128); } __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_6getxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_size_guess, __pyx_v_namespace); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_6getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, int __pyx_v_size_guess, PyObject *__pyx_v_namespace) { Py_ssize_t __pyx_v_ret; char *__pyx_v_buf; char *__pyx_v_cpath; char *__pyx_v_cname; size_t __pyx_v_bufsize; int __pyx_v_cnamespace; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; char *__pyx_t_5; PyObject *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("getxattr", 0); /* "src/llfuse/fuse_api.pxi":143 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":144 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":146 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str_t): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_name, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { /* "src/llfuse/fuse_api.pxi":147 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":149 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_1 = __pyx_v_namespace; __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":151 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef ssize_t ret */ __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); /* "src/llfuse/fuse_api.pxi":150 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":161 * IF TARGET_PLATFORM == 'freebsd': * cdef int cnamespace * if namespace == 'system': # <<<<<<<<<<<<<< * cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM * else: */ __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_namespace, __pyx_n_u_system, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":162 * cdef int cnamespace * if namespace == 'system': * cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM # <<<<<<<<<<<<<< * else: * cnamespace = xattr.EXTATTR_NAMESPACE_USER */ __pyx_v_cnamespace = EXTATTR_NAMESPACE_SYSTEM; goto __pyx_L8; } /*else*/ { /* "src/llfuse/fuse_api.pxi":164 * cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM * else: * cnamespace = xattr.EXTATTR_NAMESPACE_USER # <<<<<<<<<<<<<< * * path_b = str2bytes(path) */ __pyx_v_cnamespace = EXTATTR_NAMESPACE_USER; } __pyx_L8:; /* "src/llfuse/fuse_api.pxi":166 * cnamespace = xattr.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * cpath = path_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":167 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 167; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_name_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":168 * path_b = str2bytes(path) * name_b = str2bytes(name) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cpath = ((char *)__pyx_t_5); /* "src/llfuse/fuse_api.pxi":169 * name_b = str2bytes(name) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * bufsize = size_guess */ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_name_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cname = ((char *)__pyx_t_5); /* "src/llfuse/fuse_api.pxi":171 * cname = name_b * * bufsize = size_guess # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * */ __pyx_v_bufsize = __pyx_v_size_guess; /* "src/llfuse/fuse_api.pxi":172 * * bufsize = size_guess * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * * if buf is NULL: */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "src/llfuse/fuse_api.pxi":174 * buf = stdlib.malloc(bufsize * sizeof(char)) * * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_3 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":175 * * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L9; } __pyx_L9:; /* "src/llfuse/fuse_api.pxi":177 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * with nogil: * IF TARGET_PLATFORM == 'freebsd': */ /*try:*/ { /* "src/llfuse/fuse_api.pxi":178 * * try: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":180 * with nogil: * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, # <<<<<<<<<<<<<< * buf, bufsize) * if ret == bufsize: */ __pyx_v_ret = extattr_get_file(__pyx_v_cpath, __pyx_v_cnamespace, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize); /* "src/llfuse/fuse_api.pxi":182 * ret = xattr.extattr_get_file(cpath, cnamespace, cname, * buf, bufsize) * if ret == bufsize: # <<<<<<<<<<<<<< * ret = -1 * errno.errno = errno.ERANGE */ __pyx_t_3 = ((__pyx_v_ret == __pyx_v_bufsize) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":183 * buf, bufsize) * if ret == bufsize: * ret = -1 # <<<<<<<<<<<<<< * errno.errno = errno.ERANGE * ELSE: */ __pyx_v_ret = -1; /* "src/llfuse/fuse_api.pxi":184 * if ret == bufsize: * ret = -1 * errno.errno = errno.ERANGE # <<<<<<<<<<<<<< * ELSE: * ret = xattr.getxattr(cpath, cname, buf, bufsize) */ errno = ERANGE; goto __pyx_L16; } __pyx_L16:; } /* "src/llfuse/fuse_api.pxi":178 * * try: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L15; } __pyx_L15:; } } /* "src/llfuse/fuse_api.pxi":188 * ret = xattr.getxattr(cpath, cname, buf, bufsize) * * if ret < 0 and errno.errno == errno.ERANGE: # <<<<<<<<<<<<<< * with nogil: * IF TARGET_PLATFORM == 'freebsd': */ __pyx_t_2 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L18_bool_binop_done; } __pyx_t_2 = ((errno == ERANGE) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L18_bool_binop_done:; if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":189 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":191 * with nogil: * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, # <<<<<<<<<<<<<< * NULL, 0) * ELSE: */ __pyx_v_ret = extattr_get_file(__pyx_v_cpath, __pyx_v_cnamespace, __pyx_v_cname, NULL, 0); } /* "src/llfuse/fuse_api.pxi":189 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } /* "src/llfuse/fuse_api.pxi":195 * ELSE: * ret = xattr.getxattr(cpath, cname, NULL, 0) * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret */ __pyx_t_3 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":196 * ret = xattr.getxattr(cpath, cname, NULL, 0) * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * bufsize = ret * stdlib.free(buf) */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_9) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } /* "src/llfuse/fuse_api.pxi":197 * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret # <<<<<<<<<<<<<< * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) */ __pyx_v_bufsize = ((size_t)__pyx_v_ret); /* "src/llfuse/fuse_api.pxi":198 * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret * stdlib.free(buf) # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: */ free(__pyx_v_buf); /* "src/llfuse/fuse_api.pxi":199 * bufsize = ret * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * if buf is NULL: * cpython.exc.PyErr_NoMemory() */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "src/llfuse/fuse_api.pxi":200 * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_3 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":201 * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 201; __pyx_clineno = __LINE__; goto __pyx_L11_error;} goto __pyx_L24; } __pyx_L24:; /* "src/llfuse/fuse_api.pxi":203 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":205 * with nogil: * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, # <<<<<<<<<<<<<< * buf, bufsize) * ELSE: */ __pyx_v_ret = extattr_get_file(__pyx_v_cpath, __pyx_v_cnamespace, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize); } /* "src/llfuse/fuse_api.pxi":203 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L27; } __pyx_L27:; } } goto __pyx_L17; } __pyx_L17:; /* "src/llfuse/fuse_api.pxi":210 * ret = xattr.getxattr(cpath, cname, buf, bufsize) * * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":211 * * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * return PyBytes_FromStringAndSize(buf, ret) */ __pyx_t_4 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_8) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_4 = 0; __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } /* "src/llfuse/fuse_api.pxi":213 * raise OSError(errno.errno, strerror(errno.errno), path) * * return PyBytes_FromStringAndSize(buf, ret) # <<<<<<<<<<<<<< * * finally: */ __Pyx_XDECREF(__pyx_r); __pyx_t_7 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_ret); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 213; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L10_return; } /* "src/llfuse/fuse_api.pxi":216 * * finally: * stdlib.free(buf) # <<<<<<<<<<<<<< * * def init(ops, mountpoint, list args): */ /*finally:*/ { /*exception exit:*/{ __pyx_L11_error:; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_11 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { free(__pyx_v_buf); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L1_error; } __pyx_L10_return: { __pyx_t_19 = __pyx_r; __pyx_r = 0; free(__pyx_v_buf); __pyx_r = __pyx_t_19; __pyx_t_19 = 0; goto __pyx_L0; } } /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("llfuse.capi.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_9init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_8init[] = "init(ops, mountpoint, list args)\nInitialize and mount FUSE file system\n\n *ops* has to be an instance of the `Operations` class (or another\n class defining the same methods).\n\n *args* has to be a list of strings. Valid options are listed under ``struct\n fuse_opt fuse_mount_opts[]``\n (`mount.c:82 `_)\n and ``struct fuse_opt fuse_ll_opts[]``\n (`fuse_lowlevel_c:2209 `_).\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_9init = {"init", (PyCFunction)__pyx_pw_6llfuse_4capi_9init, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_8init}; static PyObject *__pyx_pw_6llfuse_4capi_9init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_ops = 0; PyObject *__pyx_v_mountpoint = 0; PyObject *__pyx_v_args = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ops,&__pyx_n_s_mountpoint,&__pyx_n_s_args,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ops)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mountpoint)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, 2); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "init") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_ops = values[0]; __pyx_v_mountpoint = values[1]; __pyx_v_args = ((PyObject*)values[2]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyList_Type), 1, "args", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_8init(__pyx_self, __pyx_v_ops, __pyx_v_mountpoint, __pyx_v_args); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_8init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_args) { struct fuse_args __pyx_v_f_args; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; char *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("init", 0); /* "src/llfuse/fuse_api.pxi":231 * ''' * * log.debug('Initializing llfuse') # <<<<<<<<<<<<<< * cdef fuse_args f_args * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":234 * cdef fuse_args f_args * * if not isinstance(mountpoint, str_t): # <<<<<<<<<<<<<< * raise TypeError('*mountpoint_* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_mountpoint, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":235 * * if not isinstance(mountpoint, str_t): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":243 * global channel * * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) # <<<<<<<<<<<<<< * operations = ops * */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_path); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_abspath); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_5) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_mountpoint); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; __Pyx_INCREF(__pyx_v_mountpoint); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_mountpoint); __Pyx_GIVEREF(__pyx_v_mountpoint); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_mountpoint_b, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":244 * * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) * operations = ops # <<<<<<<<<<<<<< * * # Initialize Python thread support */ __Pyx_INCREF(__pyx_v_ops); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_operations); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_operations, __pyx_v_ops); __Pyx_GIVEREF(__pyx_v_ops); /* "src/llfuse/fuse_api.pxi":247 * * # Initialize Python thread support * PyEval_InitThreads() # <<<<<<<<<<<<<< * * make_fuse_args(args, &f_args) */ PyEval_InitThreads(); /* "src/llfuse/fuse_api.pxi":249 * PyEval_InitThreads() * * make_fuse_args(args, &f_args) # <<<<<<<<<<<<<< * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) */ __pyx_t_2 = __pyx_f_6llfuse_4capi_make_fuse_args(__pyx_v_args, (&__pyx_v_f_args)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 249; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":250 * * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') # <<<<<<<<<<<<<< * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":251 * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) # <<<<<<<<<<<<<< * if not channel: * raise RuntimeError('fuse_mount failed') */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 251; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_6llfuse_4capi_channel = fuse_mount(((char *)__pyx_t_7), (&__pyx_v_f_args)); /* "src/llfuse/fuse_api.pxi":252 * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: # <<<<<<<<<<<<<< * raise RuntimeError('fuse_mount failed') * */ __pyx_t_4 = ((!(__pyx_v_6llfuse_4capi_channel != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":253 * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: * raise RuntimeError('fuse_mount failed') # <<<<<<<<<<<<<< * * log.debug('Calling fuse_lowlevel_new') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":255 * raise RuntimeError('fuse_mount failed') * * log.debug('Calling fuse_lowlevel_new') # <<<<<<<<<<<<<< * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":256 * * log.debug('Calling fuse_lowlevel_new') * init_fuse_ops() # <<<<<<<<<<<<<< * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: */ __pyx_f_6llfuse_4capi_init_fuse_ops(); /* "src/llfuse/fuse_api.pxi":257 * log.debug('Calling fuse_lowlevel_new') * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) # <<<<<<<<<<<<<< * if not session: * fuse_unmount(mountpoint_b, channel) */ __pyx_v_6llfuse_4capi_session = fuse_lowlevel_new((&__pyx_v_f_args), (&__pyx_v_6llfuse_4capi_fuse_ops), (sizeof(__pyx_v_6llfuse_4capi_fuse_ops)), NULL); /* "src/llfuse/fuse_api.pxi":258 * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") */ __pyx_t_4 = ((!(__pyx_v_6llfuse_4capi_session != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":259 * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * raise RuntimeError("fuse_lowlevel_new() failed") * */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_7), __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":260 * if not session: * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_set_signal_handlers') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":262 * raise RuntimeError("fuse_lowlevel_new() failed") * * log.debug('Calling fuse_set_signal_handlers') # <<<<<<<<<<<<<< * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":263 * * log.debug('Calling fuse_set_signal_handlers') * if fuse_set_signal_handlers(session) == -1: # <<<<<<<<<<<<<< * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) */ __pyx_t_4 = ((fuse_set_signal_handlers(__pyx_v_6llfuse_4capi_session) == -1) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":264 * log.debug('Calling fuse_set_signal_handlers') * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") */ fuse_session_destroy(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":265 * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * raise RuntimeError("fuse_set_signal_handlers() failed") * */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_7), __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":266 * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_add_chan') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":268 * raise RuntimeError("fuse_set_signal_handlers() failed") * * log.debug('Calling fuse_session_add_chan') # <<<<<<<<<<<<<< * fuse_session_add_chan(session, channel) * */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":269 * * log.debug('Calling fuse_session_add_chan') * fuse_session_add_chan(session, channel) # <<<<<<<<<<<<<< * * def main(single=False): */ fuse_session_add_chan(__pyx_v_6llfuse_4capi_session, __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_11main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_10main[] = "main(single=False)\nRun FUSE main loop\n\n If *single* is True, all requests will be handled sequentially by\n the thread that has called `main`. If *single* is False, multiple\n worker threads will be started and work on requests concurrently.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_11main = {"main", (PyCFunction)__pyx_pw_6llfuse_4capi_11main, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_10main}; static PyObject *__pyx_pw_6llfuse_4capi_11main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_single = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("main (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_single,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_single); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "main") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_single = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("main", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_10main(__pyx_self, __pyx_v_single); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_10main(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_single) { int __pyx_v_ret; PyObject *__pyx_v_t = NULL; PyObject *__pyx_v_tmp = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("main", 0); /* "src/llfuse/fuse_api.pxi":282 * global exc_info * * if session == NULL: # <<<<<<<<<<<<<< * raise RuntimeError('Need to call init() before main()') * */ __pyx_t_1 = ((__pyx_v_6llfuse_4capi_session == NULL) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":283 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * # Start notification handling thread */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":286 * * # Start notification handling thread * t = threading.Thread(target=_notify_loop) # <<<<<<<<<<<<<< * t.daemon = True * t.start() */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_threading); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Thread); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_loop); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_target, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_t = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":287 * # Start notification handling thread * t = threading.Thread(target=_notify_loop) * t.daemon = True # <<<<<<<<<<<<<< * t.start() * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_daemon, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":288 * t = threading.Thread(target=_notify_loop) * t.daemon = True * t.start() # <<<<<<<<<<<<<< * * exc_info = None */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_start); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":290 * t.start() * * exc_info = None # <<<<<<<<<<<<<< * * if single: */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":292 * exc_info = None * * if single: # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_loop') * with nogil: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_single); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 292; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":293 * * if single: * log.debug('Calling fuse_session_loop') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop(session) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":294 * if single: * log.debug('Calling fuse_session_loop') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":295 * log.debug('Calling fuse_session_loop') * with nogil: * ret = fuse_session_loop(session) # <<<<<<<<<<<<<< * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: */ __pyx_v_ret = fuse_session_loop(__pyx_v_6llfuse_4capi_session); } /* "src/llfuse/fuse_api.pxi":294 * if single: * log.debug('Calling fuse_session_loop') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L7; } __pyx_L7:; } } /* "src/llfuse/fuse_api.pxi":296 * with nogil: * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop failed") */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_put); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_block, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_timeout, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__66, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/fuse_api.pxi":297 * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_loop failed") * else: */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":298 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop failed") # <<<<<<<<<<<<<< * else: * log.debug('Calling fuse_session_loop_mt') */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } goto __pyx_L4; } /*else*/ { /* "src/llfuse/fuse_api.pxi":300 * raise RuntimeError("fuse_session_loop failed") * else: * log.debug('Calling fuse_session_loop_mt') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop_mt(session) */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/fuse_api.pxi":301 * else: * log.debug('Calling fuse_session_loop_mt') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":302 * log.debug('Calling fuse_session_loop_mt') * with nogil: * ret = fuse_session_loop_mt(session) # <<<<<<<<<<<<<< * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: */ __pyx_v_ret = fuse_session_loop_mt(__pyx_v_6llfuse_4capi_session); } /* "src/llfuse/fuse_api.pxi":301 * else: * log.debug('Calling fuse_session_loop_mt') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L11; } __pyx_L11:; } } /* "src/llfuse/fuse_api.pxi":303 * with nogil: * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_put); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_block, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_timeout, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__69, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":304 * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_loop_mt() failed") * */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":305 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") # <<<<<<<<<<<<<< * * if exc_info: */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } __pyx_L4:; /* "src/llfuse/fuse_api.pxi":307 * raise RuntimeError("fuse_session_loop_mt() failed") * * if exc_info: # <<<<<<<<<<<<<< * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 307; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":309 * if exc_info: * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":310 * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') * tmp = exc_info # <<<<<<<<<<<<<< * exc_info = None * */ __Pyx_INCREF(__pyx_v_6llfuse_4capi_exc_info); __pyx_v_tmp = __pyx_v_6llfuse_4capi_exc_info; /* "src/llfuse/fuse_api.pxi":311 * log.debug('Terminated main loop because request handler raised exception, re-raising..') * tmp = exc_info * exc_info = None # <<<<<<<<<<<<<< * * # The explicit version check works around a Cython bug with */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":316 * # the 3-parameter version of the raise statement, c.f. * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise tmp[0], tmp[1], tmp[2] * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":317 * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: * raise tmp[0], tmp[1], tmp[2] # <<<<<<<<<<<<<< * else: * raise tmp[1].with_traceback(tmp[2]) */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_2, __pyx_t_3, __pyx_t_4, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/fuse_api.pxi":319 * raise tmp[0], tmp[1], tmp[2] * else: * raise tmp[1].with_traceback(tmp[2]) # <<<<<<<<<<<<<< * * def close(unmount=True): */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_with_traceback); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_5) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_t); __Pyx_XDECREF(__pyx_v_tmp); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_12close[] = "close(unmount=True)\nUnmount file system and clean up\n\n If *unmount* is False, only clean up operations are peformed, but\n the file system is not unmounted. As long as the file system\n process is still running, all requests will hang. Once the process\n has terminated, these (and all future) requests fail with ESHUTDOWN.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_13close = {"close", (PyCFunction)__pyx_pw_6llfuse_4capi_13close, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_12close}; static PyObject *__pyx_pw_6llfuse_4capi_13close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_unmount = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_unmount,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_True); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_unmount); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "close") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_unmount = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("close", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_12close(__pyx_self, __pyx_v_unmount); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_12close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount) { PyObject *__pyx_v_tmp = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close", 0); /* "src/llfuse/fuse_api.pxi":335 * global exc_info * * log.debug('Calling fuse_session_remove_chan') # <<<<<<<<<<<<<< * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":336 * * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) # <<<<<<<<<<<<<< * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) */ fuse_session_remove_chan(__pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":337 * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') # <<<<<<<<<<<<<< * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":338 * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_destroy') * fuse_session_destroy(session) */ fuse_remove_signal_handlers(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":339 * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') # <<<<<<<<<<<<<< * fuse_session_destroy(session) * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":340 * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') * fuse_session_destroy(session) # <<<<<<<<<<<<<< * * if unmount: */ fuse_session_destroy(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":342 * fuse_session_destroy(session) * * if unmount: # <<<<<<<<<<<<<< * log.debug('Calling fuse_unmount') * fuse_unmount(mountpoint_b, channel) */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_unmount); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":343 * * if unmount: * log.debug('Calling fuse_unmount') # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * else: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":344 * if unmount: * log.debug('Calling fuse_unmount') * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * else: * fuse_chan_destroy(channel) */ __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_4), __pyx_v_6llfuse_4capi_channel); goto __pyx_L3; } /*else*/ { /* "src/llfuse/fuse_api.pxi":346 * fuse_unmount(mountpoint_b, channel) * else: * fuse_chan_destroy(channel) # <<<<<<<<<<<<<< * * mountpoint_b = None */ fuse_chan_destroy(__pyx_v_6llfuse_4capi_channel); } __pyx_L3:; /* "src/llfuse/fuse_api.pxi":348 * fuse_chan_destroy(channel) * * mountpoint_b = None # <<<<<<<<<<<<<< * session = NULL * channel = NULL */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_mountpoint_b, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":349 * * mountpoint_b = None * session = NULL # <<<<<<<<<<<<<< * channel = NULL * */ __pyx_v_6llfuse_4capi_session = NULL; /* "src/llfuse/fuse_api.pxi":350 * mountpoint_b = None * session = NULL * channel = NULL # <<<<<<<<<<<<<< * * # destroy handler may have given us an exception */ __pyx_v_6llfuse_4capi_channel = NULL; /* "src/llfuse/fuse_api.pxi":353 * * # destroy handler may have given us an exception * if exc_info: # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":354 * # destroy handler may have given us an exception * if exc_info: * tmp = exc_info # <<<<<<<<<<<<<< * exc_info = None * */ __Pyx_INCREF(__pyx_v_6llfuse_4capi_exc_info); __pyx_v_tmp = __pyx_v_6llfuse_4capi_exc_info; /* "src/llfuse/fuse_api.pxi":355 * if exc_info: * tmp = exc_info * exc_info = None # <<<<<<<<<<<<<< * * # The explicit version check works around a Cython bug with */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":360 * # the 3-parameter version of the raise statement, c.f. * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise tmp[0], tmp[1], tmp[2] * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":361 * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: * raise tmp[0], tmp[1], tmp[2] # <<<<<<<<<<<<<< * else: * raise tmp[1].with_traceback(tmp[2]) */ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tmp, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_1, __pyx_t_2, __pyx_t_5, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/fuse_api.pxi":363 * raise tmp[0], tmp[1], tmp[2] * else: * raise tmp[1].with_traceback(tmp[2]) # <<<<<<<<<<<<<< * * def invalidate_inode(int inode, attr_only=False): */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_with_traceback); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_6) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_tmp); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_15invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_14invalidate_inode[] = "invalidate_inode(int inode, attr_only=False)\nInvalidate cache for *inode*\n\n Instructs the FUSE kernel module to forgot cached attributes and\n data (unless *attr_only* is True) for *inode*. This operation is\n carried out asynchronously, i.e. the method may return before the\n kernel has executed the request.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_15invalidate_inode = {"invalidate_inode", (PyCFunction)__pyx_pw_6llfuse_4capi_15invalidate_inode, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_14invalidate_inode}; static PyObject *__pyx_pw_6llfuse_4capi_15invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_inode; PyObject *__pyx_v_attr_only = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_inode (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode,&__pyx_n_s_attr_only,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inode)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_attr_only); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_inode") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_inode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_inode == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_attr_only = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_inode", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_14invalidate_inode(__pyx_self, __pyx_v_inode, __pyx_v_attr_only); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_14invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode, PyObject *__pyx_v_attr_only) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_inode", 0); /* "src/llfuse/fuse_api.pxi":374 * ''' * * _notify_queue.put(inval_inode_req(inode, attr_only)) # <<<<<<<<<<<<<< * * def invalidate_entry(int inode_p, bytes name): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_inode_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_inode); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_attr_only); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_attr_only); __Pyx_GIVEREF(__pyx_v_attr_only); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_17invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_16invalidate_entry[] = "invalidate_entry(int inode_p, bytes name)\nInvalidate directory entry\n\n Instructs the FUSE kernel module to forget about the directory\n entry *name* in the directory with inode *inode_p*. This operation\n is carried out asynchronously, i.e. the method may return before\n the kernel has executed the request.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_17invalidate_entry = {"invalidate_entry", (PyCFunction)__pyx_pw_6llfuse_4capi_17invalidate_entry, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_16invalidate_entry}; static PyObject *__pyx_pw_6llfuse_4capi_17invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_inode_p; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_entry (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode_p,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inode_p)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("invalidate_entry", 1, 2, 2, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_entry") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_inode_p = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_inode_p == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_name = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_entry", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_16invalidate_entry(__pyx_self, __pyx_v_inode_p, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_16invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode_p, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_entry", 0); /* "src/llfuse/fuse_api.pxi":385 * ''' * * _notify_queue.put(inval_entry_req(inode_p, name)) # <<<<<<<<<<<<<< * * def get_ino_t_bits(): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_entry_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_inode_p); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_19get_ino_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_18get_ino_t_bits[] = "get_ino_t_bits()\nReturn number of bits available for inode numbers\n\n Attempts to use inode values that need more bytes will result in\n `OverflowError`.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_19get_ino_t_bits = {"get_ino_t_bits", (PyCFunction)__pyx_pw_6llfuse_4capi_19get_ino_t_bits, METH_NOARGS, __pyx_doc_6llfuse_4capi_18get_ino_t_bits}; static PyObject *__pyx_pw_6llfuse_4capi_19get_ino_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_ino_t_bits (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_18get_ino_t_bits(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_18get_ino_t_bits(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations size_t __pyx_t_1; size_t __pyx_t_2; size_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_ino_t_bits", 0); /* "src/llfuse/fuse_api.pxi":393 * `OverflowError`. * ''' * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 # <<<<<<<<<<<<<< * * def get_off_t_bits(): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = (sizeof(fuse_ino_t)); __pyx_t_2 = (sizeof(ino_t)); if (((__pyx_t_1 < __pyx_t_2) != 0)) { __pyx_t_3 = __pyx_t_1; } else { __pyx_t_3 = __pyx_t_2; } __pyx_t_4 = __Pyx_PyInt_FromSize_t((__pyx_t_3 * 8)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 393; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("llfuse.capi.get_ino_t_bits", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_21get_off_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_20get_off_t_bits[] = "get_off_t_bits()\nReturn number of bytes available for file offsets\n\n Attempts to use values whose representation needs more bytes will\n result in `OverflowError`.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_21get_off_t_bits = {"get_off_t_bits", (PyCFunction)__pyx_pw_6llfuse_4capi_21get_off_t_bits, METH_NOARGS, __pyx_doc_6llfuse_4capi_20get_off_t_bits}; static PyObject *__pyx_pw_6llfuse_4capi_21get_off_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_off_t_bits (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_20get_off_t_bits(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_20get_off_t_bits(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_off_t_bits", 0); /* "src/llfuse/fuse_api.pxi":401 * result in `OverflowError`. * ''' * return sizeof(off_t) * 8 # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_FromSize_t(((sizeof(off_t)) * 8)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 401; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.get_off_t_bits", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_tp_new_6llfuse_4capi_Lock(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; return o; } static void __pyx_tp_dealloc_6llfuse_4capi_Lock(PyObject *o) { #if PY_VERSION_HEX >= 0x030400a1 if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif (*Py_TYPE(o)->tp_free)(o); } static PyMethodDef __pyx_methods_6llfuse_4capi_Lock[] = { {"acquire", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_3acquire, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_2acquire}, {"release", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_5release, METH_NOARGS, __pyx_doc_6llfuse_4capi_4Lock_4release}, {"yield_", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_7yield_, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_6yield_}, {"__enter__", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_9__enter__, METH_NOARGS, __pyx_doc_6llfuse_4capi_4Lock_8__enter__}, {"__exit__", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_11__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_10__exit__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6llfuse_4capi_Lock = { PyVarObject_HEAD_INIT(0, 0) "llfuse.capi.Lock", /*tp_name*/ sizeof(struct __pyx_obj_6llfuse_4capi_Lock), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6llfuse_4capi_Lock, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "Lock()\n\n This is the class of lock itself as well as a context manager to\n execute code while the global lock is being held.\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6llfuse_4capi_Lock, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_6llfuse_4capi_4Lock_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6llfuse_4capi_Lock, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyObject *__pyx_tp_new_6llfuse_4capi_NoLockManager(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; return o; } static void __pyx_tp_dealloc_6llfuse_4capi_NoLockManager(PyObject *o) { #if PY_VERSION_HEX >= 0x030400a1 if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif (*Py_TYPE(o)->tp_free)(o); } static PyMethodDef __pyx_methods_6llfuse_4capi_NoLockManager[] = { {"__enter__", (PyCFunction)__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__, METH_NOARGS, __pyx_doc_6llfuse_4capi_13NoLockManager_2__enter__}, {"__exit__", (PyCFunction)__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_13NoLockManager_4__exit__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6llfuse_4capi_NoLockManager = { PyVarObject_HEAD_INIT(0, 0) "llfuse.capi.NoLockManager", /*tp_name*/ sizeof(struct __pyx_obj_6llfuse_4capi_NoLockManager), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6llfuse_4capi_NoLockManager, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "NoLockManager()\nContext manager to execute code while the global lock is released", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6llfuse_4capi_NoLockManager, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6llfuse_4capi_NoLockManager, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { #if PY_VERSION_HEX < 0x03020000 { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, #else PyModuleDef_HEAD_INIT, #endif "capi", __pyx_k_capi_pxy_Copyright_2013_Nikolau, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_BaseException, __pyx_k_BaseException, sizeof(__pyx_k_BaseException), 0, 0, 1, 1}, {&__pyx_kp_u_Calling_fuse_lowlevel_new, __pyx_k_Calling_fuse_lowlevel_new, sizeof(__pyx_k_Calling_fuse_lowlevel_new), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_mount, __pyx_k_Calling_fuse_mount, sizeof(__pyx_k_Calling_fuse_mount), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_remove_signal_handl, __pyx_k_Calling_fuse_remove_signal_handl, sizeof(__pyx_k_Calling_fuse_remove_signal_handl), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_add_chan, __pyx_k_Calling_fuse_session_add_chan, sizeof(__pyx_k_Calling_fuse_session_add_chan), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_destroy, __pyx_k_Calling_fuse_session_destroy, sizeof(__pyx_k_Calling_fuse_session_destroy), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_loop, __pyx_k_Calling_fuse_session_loop, sizeof(__pyx_k_Calling_fuse_session_loop), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_loop_mt, __pyx_k_Calling_fuse_session_loop_mt, sizeof(__pyx_k_Calling_fuse_session_loop_mt), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_remove_chan, __pyx_k_Calling_fuse_session_remove_chan, sizeof(__pyx_k_Calling_fuse_session_remove_chan), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_set_signal_handlers, __pyx_k_Calling_fuse_set_signal_handlers, sizeof(__pyx_k_Calling_fuse_set_signal_handlers), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_unmount, __pyx_k_Calling_fuse_unmount, sizeof(__pyx_k_Calling_fuse_unmount), 0, 1, 0, 0}, {&__pyx_n_s_ENOATTR, __pyx_k_ENOATTR, sizeof(__pyx_k_ENOATTR), 0, 0, 1, 1}, {&__pyx_n_s_EntryAttributes, __pyx_k_EntryAttributes, sizeof(__pyx_k_EntryAttributes), 0, 0, 1, 1}, {&__pyx_kp_u_Exception_after_kill, __pyx_k_Exception_after_kill, sizeof(__pyx_k_Exception_after_kill), 0, 1, 0, 0}, {&__pyx_n_s_FUSEError, __pyx_k_FUSEError, sizeof(__pyx_k_FUSEError), 0, 0, 1, 1}, {&__pyx_kp_u_Global_lock_cannot_be_acquired_m, __pyx_k_Global_lock_cannot_be_acquired_m, sizeof(__pyx_k_Global_lock_cannot_be_acquired_m), 0, 1, 0, 0}, {&__pyx_kp_u_Initializing_llfuse, __pyx_k_Initializing_llfuse, sizeof(__pyx_k_Initializing_llfuse), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_can_only_be_released_by_the, __pyx_k_Lock_can_only_be_released_by_the, sizeof(__pyx_k_Lock_can_only_be_released_by_the), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_not_initialized, __pyx_k_Lock_not_initialized, sizeof(__pyx_k_Lock_not_initialized), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_still_taken_after_receiving, __pyx_k_Lock_still_taken_after_receiving, sizeof(__pyx_k_Lock_still_taken_after_receiving), 0, 1, 0, 0}, {&__pyx_kp_u_Need_to_call_init_before_main, __pyx_k_Need_to_call_init_before_main, sizeof(__pyx_k_Need_to_call_init_before_main), 0, 1, 0, 0}, {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1}, {&__pyx_n_s_Operations, __pyx_k_Operations, sizeof(__pyx_k_Operations), 0, 0, 1, 1}, {&__pyx_kp_u_Other_thread_didn_t_take_lock, __pyx_k_Other_thread_didn_t_take_lock, sizeof(__pyx_k_Other_thread_didn_t_take_lock), 0, 1, 0, 0}, {&__pyx_kp_b_Python_LLFUSE, __pyx_k_Python_LLFUSE, sizeof(__pyx_k_Python_LLFUSE), 0, 0, 0, 0}, {&__pyx_n_s_Queue, __pyx_k_Queue, sizeof(__pyx_k_Queue), 0, 0, 1, 1}, {&__pyx_n_s_ROOT_INODE, __pyx_k_ROOT_INODE, sizeof(__pyx_k_ROOT_INODE), 0, 0, 1, 1}, {&__pyx_n_s_RequestContext, __pyx_k_RequestContext, sizeof(__pyx_k_RequestContext), 0, 0, 1, 1}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_kp_u_Terminated_main_loop_because_req, __pyx_k_Terminated_main_loop_because_req, sizeof(__pyx_k_Terminated_main_loop_because_req), 0, 1, 0, 0}, {&__pyx_n_s_Thread, __pyx_k_Thread, sizeof(__pyx_k_Thread), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_kp_u_Weird_request_received_r, __pyx_k_Weird_request_received_r, sizeof(__pyx_k_Weird_request_received_r), 0, 1, 0, 0}, {&__pyx_kp_u_You_should_not_instantiate_this, __pyx_k_You_should_not_instantiate_this, sizeof(__pyx_k_You_should_not_instantiate_this), 0, 1, 0, 0}, {&__pyx_kp_b__28, __pyx_k__28, sizeof(__pyx_k__28), 0, 0, 0, 0}, {&__pyx_n_s_abspath, __pyx_k_abspath, sizeof(__pyx_k_abspath), 0, 0, 1, 1}, {&__pyx_n_s_access, __pyx_k_access, sizeof(__pyx_k_access), 0, 0, 1, 1}, {&__pyx_n_s_acquire, __pyx_k_acquire, sizeof(__pyx_k_acquire), 0, 0, 1, 1}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_attr_only, __pyx_k_attr_only, sizeof(__pyx_k_attr_only), 0, 0, 1, 1}, {&__pyx_n_u_attr_only, __pyx_k_attr_only, sizeof(__pyx_k_attr_only), 0, 1, 0, 1}, {&__pyx_n_s_attr_timeout, __pyx_k_attr_timeout, sizeof(__pyx_k_attr_timeout), 0, 0, 1, 1}, {&__pyx_n_s_block, __pyx_k_block, sizeof(__pyx_k_block), 0, 0, 1, 1}, {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1}, {&__pyx_n_s_bufsize, __pyx_k_bufsize, sizeof(__pyx_k_bufsize), 0, 0, 1, 1}, {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, {&__pyx_n_s_cname, __pyx_k_cname, sizeof(__pyx_k_cname), 0, 0, 1, 1}, {&__pyx_n_s_cnamespace, __pyx_k_cnamespace, sizeof(__pyx_k_cnamespace), 0, 0, 1, 1}, {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, {&__pyx_n_s_cpath, __pyx_k_cpath, sizeof(__pyx_k_cpath), 0, 0, 1, 1}, {&__pyx_n_s_create, __pyx_k_create, sizeof(__pyx_k_create), 0, 0, 1, 1}, {&__pyx_n_s_cvalue, __pyx_k_cvalue, sizeof(__pyx_k_cvalue), 0, 0, 1, 1}, {&__pyx_n_s_daemon, __pyx_k_daemon, sizeof(__pyx_k_daemon), 0, 0, 1, 1}, {&__pyx_n_s_debug, __pyx_k_debug, sizeof(__pyx_k_debug), 0, 0, 1, 1}, {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, {&__pyx_n_s_destroy, __pyx_k_destroy, sizeof(__pyx_k_destroy), 0, 0, 1, 1}, {&__pyx_n_s_dirp, __pyx_k_dirp, sizeof(__pyx_k_dirp), 0, 0, 1, 1}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_ent, __pyx_k_ent, sizeof(__pyx_k_ent), 0, 0, 1, 1}, {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, {&__pyx_n_s_entry_timeout, __pyx_k_entry_timeout, sizeof(__pyx_k_entry_timeout), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_errno, __pyx_k_errno, sizeof(__pyx_k_errno), 0, 0, 1, 1}, {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_exc_info, __pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 0, 1, 1}, {&__pyx_n_s_exc_tb, __pyx_k_exc_tb, sizeof(__pyx_k_exc_tb), 0, 0, 1, 1}, {&__pyx_n_s_exc_type, __pyx_k_exc_type, sizeof(__pyx_k_exc_type), 0, 0, 1, 1}, {&__pyx_n_s_exc_val, __pyx_k_exc_val, sizeof(__pyx_k_exc_val), 0, 0, 1, 1}, {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, {&__pyx_n_s_f_args, __pyx_k_f_args, sizeof(__pyx_k_f_args), 0, 0, 1, 1}, {&__pyx_n_s_f_bavail, __pyx_k_f_bavail, sizeof(__pyx_k_f_bavail), 0, 0, 1, 1}, {&__pyx_n_s_f_bfree, __pyx_k_f_bfree, sizeof(__pyx_k_f_bfree), 0, 0, 1, 1}, {&__pyx_n_s_f_blocks, __pyx_k_f_blocks, sizeof(__pyx_k_f_blocks), 0, 0, 1, 1}, {&__pyx_n_s_f_bsize, __pyx_k_f_bsize, sizeof(__pyx_k_f_bsize), 0, 0, 1, 1}, {&__pyx_n_s_f_favail, __pyx_k_f_favail, sizeof(__pyx_k_f_favail), 0, 0, 1, 1}, {&__pyx_n_s_f_ffree, __pyx_k_f_ffree, sizeof(__pyx_k_f_ffree), 0, 0, 1, 1}, {&__pyx_n_s_f_files, __pyx_k_f_files, sizeof(__pyx_k_f_files), 0, 0, 1, 1}, {&__pyx_n_s_f_frsize, __pyx_k_f_frsize, sizeof(__pyx_k_f_frsize), 0, 0, 1, 1}, {&__pyx_n_s_flush, __pyx_k_flush, sizeof(__pyx_k_flush), 0, 0, 1, 1}, {&__pyx_n_s_forget, __pyx_k_forget, sizeof(__pyx_k_forget), 0, 0, 1, 1}, {&__pyx_n_s_fse, __pyx_k_fse, sizeof(__pyx_k_fse), 0, 0, 1, 1}, {&__pyx_n_s_fsync, __pyx_k_fsync, sizeof(__pyx_k_fsync), 0, 0, 1, 1}, {&__pyx_n_s_fsyncdir, __pyx_k_fsyncdir, sizeof(__pyx_k_fsyncdir), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_access_fuse_reply__failed_w, __pyx_k_fuse_access_fuse_reply__failed_w, sizeof(__pyx_k_fuse_access_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_create_fuse_reply__failed_w, __pyx_k_fuse_create_fuse_reply__failed_w, sizeof(__pyx_k_fuse_create_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_flush_fuse_reply__failed_wi, __pyx_k_fuse_flush_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_flush_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi, __pyx_k_fuse_fsync_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_fsync_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed, __pyx_k_fuse_fsyncdir_fuse_reply__failed, sizeof(__pyx_k_fuse_fsyncdir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_getattr_fuse_reply__failed, __pyx_k_fuse_getattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_getxattr_fuse_reply__failed, __pyx_k_fuse_getxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_k_fuse_link_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_link_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_listxattr_fuse_reply__faile, __pyx_k_fuse_listxattr_fuse_reply__faile, sizeof(__pyx_k_fuse_listxattr_fuse_reply__faile), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lookup_fuse_reply__failed_w, __pyx_k_fuse_lookup_fuse_reply__failed_w, sizeof(__pyx_k_fuse_lookup_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lowlevel_new_failed, __pyx_k_fuse_lowlevel_new_failed, sizeof(__pyx_k_fuse_lowlevel_new_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi, __pyx_k_fuse_mkdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mkdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi, __pyx_k_fuse_mknod_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mknod_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mount_failed, __pyx_k_fuse_mount_failed, sizeof(__pyx_k_fuse_mount_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_opendir_fuse_reply__failed, __pyx_k_fuse_opendir_fuse_reply__failed, sizeof(__pyx_k_fuse_opendir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_options_must_be_of_type_str, __pyx_k_fuse_options_must_be_of_type_str, sizeof(__pyx_k_fuse_options_must_be_of_type_str), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_read_fuse_reply__failed_wit, __pyx_k_fuse_read_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_read_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_readdir_fuse_reply__failed, __pyx_k_fuse_readdir_fuse_reply__failed, sizeof(__pyx_k_fuse_readdir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_readlink_fuse_reply__failed, __pyx_k_fuse_readlink_fuse_reply__failed, sizeof(__pyx_k_fuse_readlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_release_fuse_reply__failed, __pyx_k_fuse_release_fuse_reply__failed, sizeof(__pyx_k_fuse_release_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_releasedir_fuse_reply__fail, __pyx_k_fuse_releasedir_fuse_reply__fail, sizeof(__pyx_k_fuse_releasedir_fuse_reply__fail), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_removexattr_fuse_reply__fai, __pyx_k_fuse_removexattr_fuse_reply__fai, sizeof(__pyx_k_fuse_removexattr_fuse_reply__fai), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_rename_fuse_reply__failed_w, __pyx_k_fuse_rename_fuse_reply__failed_w, sizeof(__pyx_k_fuse_rename_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi, __pyx_k_fuse_rmdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_rmdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_loop_failed, __pyx_k_fuse_session_loop_failed, sizeof(__pyx_k_fuse_session_loop_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_loop_mt_failed, __pyx_k_fuse_session_loop_mt_failed, sizeof(__pyx_k_fuse_session_loop_mt_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_set_signal_handlers_failed, __pyx_k_fuse_set_signal_handlers_failed, sizeof(__pyx_k_fuse_set_signal_handlers_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK, __pyx_k_fuse_setattr_clock_gettime_CLOCK, sizeof(__pyx_k_fuse_setattr_clock_gettime_CLOCK), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setattr_fuse_reply__failed, __pyx_k_fuse_setattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setxattr_fuse_reply__failed, __pyx_k_fuse_setxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_statfs_fuse_reply__failed_w, __pyx_k_fuse_statfs_fuse_reply__failed_w, sizeof(__pyx_k_fuse_statfs_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_symlink_fuse_reply__failed, __pyx_k_fuse_symlink_fuse_reply__failed, sizeof(__pyx_k_fuse_symlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_unlink_fuse_reply__failed_w, __pyx_k_fuse_unlink_fuse_reply__failed_w, sizeof(__pyx_k_fuse_unlink_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_err_d_fail, __pyx_k_fuse_write_fuse_reply_err_d_fail, sizeof(__pyx_k_fuse_write_fuse_reply_err_d_fail), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_err_failed, __pyx_k_fuse_write_fuse_reply_err_failed, sizeof(__pyx_k_fuse_write_fuse_reply_err_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_write_fail, __pyx_k_fuse_write_fuse_reply_write_fail, sizeof(__pyx_k_fuse_write_fuse_reply_write_fail), 0, 1, 0, 0}, {&__pyx_n_s_generation, __pyx_k_generation, sizeof(__pyx_k_generation), 0, 0, 1, 1}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_getLogger, __pyx_k_getLogger, sizeof(__pyx_k_getLogger), 0, 0, 1, 1}, {&__pyx_n_s_get_ino_t_bits, __pyx_k_get_ino_t_bits, sizeof(__pyx_k_get_ino_t_bits), 0, 0, 1, 1}, {&__pyx_n_s_get_off_t_bits, __pyx_k_get_off_t_bits, sizeof(__pyx_k_get_off_t_bits), 0, 0, 1, 1}, {&__pyx_n_s_getattr, __pyx_k_getattr, sizeof(__pyx_k_getattr), 0, 0, 1, 1}, {&__pyx_n_s_getfilesystemencoding, __pyx_k_getfilesystemencoding, sizeof(__pyx_k_getfilesystemencoding), 0, 0, 1, 1}, {&__pyx_n_s_getxattr, __pyx_k_getxattr, sizeof(__pyx_k_getxattr), 0, 0, 1, 1}, {&__pyx_n_s_gid, __pyx_k_gid, sizeof(__pyx_k_gid), 0, 0, 1, 1}, {&__pyx_kp_u_handler_raised_exception_sending, __pyx_k_handler_raised_exception_sending, sizeof(__pyx_k_handler_raised_exception_sending), 0, 1, 0, 0}, {&__pyx_kp_s_home_nikratio_in_progress_pytho, __pyx_k_home_nikratio_in_progress_pytho, sizeof(__pyx_k_home_nikratio_in_progress_pytho), 0, 0, 1, 0}, {&__pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_k_home_nikratio_in_progress_pytho_2, sizeof(__pyx_k_home_nikratio_in_progress_pytho_2), 0, 0, 1, 0}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, {&__pyx_n_s_ino, __pyx_k_ino, sizeof(__pyx_k_ino), 0, 0, 1, 1}, {&__pyx_n_s_inode, __pyx_k_inode, sizeof(__pyx_k_inode), 0, 0, 1, 1}, {&__pyx_n_u_inode, __pyx_k_inode, sizeof(__pyx_k_inode), 0, 1, 0, 1}, {&__pyx_n_s_inode_p, __pyx_k_inode_p, sizeof(__pyx_k_inode_p), 0, 0, 1, 1}, {&__pyx_n_u_inode_p, __pyx_k_inode_p, sizeof(__pyx_k_inode_p), 0, 1, 0, 1}, {&__pyx_n_s_inval_entry_req, __pyx_k_inval_entry_req, sizeof(__pyx_k_inval_entry_req), 0, 0, 1, 1}, {&__pyx_n_u_inval_entry_req, __pyx_k_inval_entry_req, sizeof(__pyx_k_inval_entry_req), 0, 1, 0, 1}, {&__pyx_n_s_inval_inode_req, __pyx_k_inval_inode_req, sizeof(__pyx_k_inval_inode_req), 0, 0, 1, 1}, {&__pyx_n_u_inval_inode_req, __pyx_k_inval_inode_req, sizeof(__pyx_k_inval_inode_req), 0, 1, 0, 1}, {&__pyx_n_s_invalidate_entry, __pyx_k_invalidate_entry, sizeof(__pyx_k_invalidate_entry), 0, 0, 1, 1}, {&__pyx_n_s_invalidate_inode, __pyx_k_invalidate_inode, sizeof(__pyx_k_invalidate_inode), 0, 0, 1, 1}, {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, {&__pyx_n_s_link, __pyx_k_link, sizeof(__pyx_k_link), 0, 0, 1, 1}, {&__pyx_n_s_listdir, __pyx_k_listdir, sizeof(__pyx_k_listdir), 0, 0, 1, 1}, {&__pyx_n_s_listxattr, __pyx_k_listxattr, sizeof(__pyx_k_listxattr), 0, 0, 1, 1}, {&__pyx_n_u_llfuse, __pyx_k_llfuse, sizeof(__pyx_k_llfuse), 0, 1, 0, 1}, {&__pyx_n_s_llfuse_capi, __pyx_k_llfuse_capi, sizeof(__pyx_k_llfuse_capi), 0, 0, 1, 1}, {&__pyx_n_s_llfuse_pyapi, __pyx_k_llfuse_pyapi, sizeof(__pyx_k_llfuse_pyapi), 0, 0, 1, 1}, {&__pyx_n_s_lock, __pyx_k_lock, sizeof(__pyx_k_lock), 0, 0, 1, 1}, {&__pyx_n_s_lock_released, __pyx_k_lock_released, sizeof(__pyx_k_lock_released), 0, 0, 1, 1}, {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1}, {&__pyx_n_s_logging, __pyx_k_logging, sizeof(__pyx_k_logging), 0, 0, 1, 1}, {&__pyx_n_s_lookup, __pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_main_2, __pyx_k_main_2, sizeof(__pyx_k_main_2), 0, 0, 1, 1}, {&__pyx_n_s_maxsize, __pyx_k_maxsize, sizeof(__pyx_k_maxsize), 0, 0, 1, 1}, {&__pyx_n_s_mkdir, __pyx_k_mkdir, sizeof(__pyx_k_mkdir), 0, 0, 1, 1}, {&__pyx_n_s_mknod, __pyx_k_mknod, sizeof(__pyx_k_mknod), 0, 0, 1, 1}, {&__pyx_n_s_mountpoint, __pyx_k_mountpoint, sizeof(__pyx_k_mountpoint), 0, 0, 1, 1}, {&__pyx_kp_u_mountpoint__argument_must_be_of, __pyx_k_mountpoint__argument_must_be_of, sizeof(__pyx_k_mountpoint__argument_must_be_of), 0, 1, 0, 0}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, {&__pyx_kp_u_name_argument_must_be_of_type_s, __pyx_k_name_argument_must_be_of_type_s, sizeof(__pyx_k_name_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_name_b, __pyx_k_name_b, sizeof(__pyx_k_name_b), 0, 0, 1, 1}, {&__pyx_n_s_namedtuple, __pyx_k_namedtuple, sizeof(__pyx_k_namedtuple), 0, 0, 1, 1}, {&__pyx_n_s_names, __pyx_k_names, sizeof(__pyx_k_names), 0, 0, 1, 1}, {&__pyx_n_s_namespace, __pyx_k_namespace, sizeof(__pyx_k_namespace), 0, 0, 1, 1}, {&__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_k_namespace_parameter_must_be_sys, sizeof(__pyx_k_namespace_parameter_must_be_sys), 0, 1, 0, 0}, {&__pyx_n_s_notify_loop, __pyx_k_notify_loop, sizeof(__pyx_k_notify_loop), 0, 0, 1, 1}, {&__pyx_n_s_notify_queue, __pyx_k_notify_queue, sizeof(__pyx_k_notify_queue), 0, 0, 1, 1}, {&__pyx_kp_b_o, __pyx_k_o, sizeof(__pyx_k_o), 0, 0, 0, 0}, {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, {&__pyx_n_s_opendir, __pyx_k_opendir, sizeof(__pyx_k_opendir), 0, 0, 1, 1}, {&__pyx_n_s_ops, __pyx_k_ops, sizeof(__pyx_k_ops), 0, 0, 1, 1}, {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, {&__pyx_n_s_os_path, __pyx_k_os_path, sizeof(__pyx_k_os_path), 0, 0, 1, 1}, {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, {&__pyx_kp_u_path_argument_must_be_of_type_s, __pyx_k_path_argument_must_be_of_type_s, sizeof(__pyx_k_path_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_path_b, __pyx_k_path_b, sizeof(__pyx_k_path_b), 0, 0, 1, 1}, {&__pyx_n_s_pid, __pyx_k_pid, sizeof(__pyx_k_pid), 0, 0, 1, 1}, {&__pyx_n_s_put, __pyx_k_put, sizeof(__pyx_k_put), 0, 0, 1, 1}, {&__pyx_n_s_queue, __pyx_k_queue, sizeof(__pyx_k_queue), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1}, {&__pyx_n_s_readdir, __pyx_k_readdir, sizeof(__pyx_k_readdir), 0, 0, 1, 1}, {&__pyx_n_s_readlink, __pyx_k_readlink, sizeof(__pyx_k_readlink), 0, 0, 1, 1}, {&__pyx_n_s_release, __pyx_k_release, sizeof(__pyx_k_release), 0, 0, 1, 1}, {&__pyx_n_s_releasedir, __pyx_k_releasedir, sizeof(__pyx_k_releasedir), 0, 0, 1, 1}, {&__pyx_n_s_removexattr, __pyx_k_removexattr, sizeof(__pyx_k_removexattr), 0, 0, 1, 1}, {&__pyx_n_s_rename, __pyx_k_rename, sizeof(__pyx_k_rename), 0, 0, 1, 1}, {&__pyx_n_s_req, __pyx_k_req, sizeof(__pyx_k_req), 0, 0, 1, 1}, {&__pyx_n_s_res, __pyx_k_res, sizeof(__pyx_k_res), 0, 0, 1, 1}, {&__pyx_n_s_ret, __pyx_k_ret, sizeof(__pyx_k_ret), 0, 0, 1, 1}, {&__pyx_n_s_rmdir, __pyx_k_rmdir, sizeof(__pyx_k_rmdir), 0, 0, 1, 1}, {&__pyx_n_s_setattr, __pyx_k_setattr, sizeof(__pyx_k_setattr), 0, 0, 1, 1}, {&__pyx_n_s_setxattr, __pyx_k_setxattr, sizeof(__pyx_k_setxattr), 0, 0, 1, 1}, {&__pyx_n_s_single, __pyx_k_single, sizeof(__pyx_k_single), 0, 0, 1, 1}, {&__pyx_n_s_size_guess, __pyx_k_size_guess, sizeof(__pyx_k_size_guess), 0, 0, 1, 1}, {&__pyx_n_s_st_atime, __pyx_k_st_atime, sizeof(__pyx_k_st_atime), 0, 0, 1, 1}, {&__pyx_n_s_st_atime_ns, __pyx_k_st_atime_ns, sizeof(__pyx_k_st_atime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_blksize, __pyx_k_st_blksize, sizeof(__pyx_k_st_blksize), 0, 0, 1, 1}, {&__pyx_n_s_st_blocks, __pyx_k_st_blocks, sizeof(__pyx_k_st_blocks), 0, 0, 1, 1}, {&__pyx_n_s_st_ctime, __pyx_k_st_ctime, sizeof(__pyx_k_st_ctime), 0, 0, 1, 1}, {&__pyx_n_s_st_ctime_ns, __pyx_k_st_ctime_ns, sizeof(__pyx_k_st_ctime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_gid, __pyx_k_st_gid, sizeof(__pyx_k_st_gid), 0, 0, 1, 1}, {&__pyx_n_s_st_ino, __pyx_k_st_ino, sizeof(__pyx_k_st_ino), 0, 0, 1, 1}, {&__pyx_n_s_st_mode, __pyx_k_st_mode, sizeof(__pyx_k_st_mode), 0, 0, 1, 1}, {&__pyx_n_s_st_mtime, __pyx_k_st_mtime, sizeof(__pyx_k_st_mtime), 0, 0, 1, 1}, {&__pyx_n_s_st_mtime_ns, __pyx_k_st_mtime_ns, sizeof(__pyx_k_st_mtime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_nlink, __pyx_k_st_nlink, sizeof(__pyx_k_st_nlink), 0, 0, 1, 1}, {&__pyx_n_s_st_rdev, __pyx_k_st_rdev, sizeof(__pyx_k_st_rdev), 0, 0, 1, 1}, {&__pyx_n_s_st_size, __pyx_k_st_size, sizeof(__pyx_k_st_size), 0, 0, 1, 1}, {&__pyx_n_s_st_uid, __pyx_k_st_uid, sizeof(__pyx_k_st_uid), 0, 0, 1, 1}, {&__pyx_n_s_stacktrace, __pyx_k_stacktrace, sizeof(__pyx_k_stacktrace), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_statfs, __pyx_k_statfs, sizeof(__pyx_k_statfs), 0, 0, 1, 1}, {&__pyx_n_s_str_t, __pyx_k_str_t, sizeof(__pyx_k_str_t), 0, 0, 1, 1}, {&__pyx_n_s_strerror, __pyx_k_strerror, sizeof(__pyx_k_strerror), 0, 0, 1, 1}, {&__pyx_n_u_surrogateescape, __pyx_k_surrogateescape, sizeof(__pyx_k_surrogateescape), 0, 1, 0, 1}, {&__pyx_n_s_symlink, __pyx_k_symlink, sizeof(__pyx_k_symlink), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_u_system, __pyx_k_system, sizeof(__pyx_k_system), 0, 1, 0, 1}, {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, {&__pyx_n_s_tmp, __pyx_k_tmp, sizeof(__pyx_k_tmp), 0, 0, 1, 1}, {&__pyx_n_s_uid, __pyx_k_uid, sizeof(__pyx_k_uid), 0, 0, 1, 1}, {&__pyx_n_s_umask, __pyx_k_umask, sizeof(__pyx_k_umask), 0, 0, 1, 1}, {&__pyx_n_s_unlink, __pyx_k_unlink, sizeof(__pyx_k_unlink), 0, 0, 1, 1}, {&__pyx_n_s_unmount, __pyx_k_unmount, sizeof(__pyx_k_unmount), 0, 0, 1, 1}, {&__pyx_kp_u_us_ascii, __pyx_k_us_ascii, sizeof(__pyx_k_us_ascii), 0, 1, 0, 0}, {&__pyx_n_u_user, __pyx_k_user, sizeof(__pyx_k_user), 0, 1, 0, 1}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, {&__pyx_n_s_with_traceback, __pyx_k_with_traceback, sizeof(__pyx_k_with_traceback), 0, 0, 1, 1}, {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_BaseException = __Pyx_GetBuiltinName(__pyx_n_s_BaseException); if (!__pyx_builtin_BaseException) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ __pyx_tuple_ = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "src/llfuse/handlers.pxi":32 * exc_info = sys.exc_info() * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Exception_after_kill); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ __pyx_tuple__3 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ __pyx_tuple__4 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ __pyx_tuple__5 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ __pyx_tuple__6 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ __pyx_tuple__7 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ __pyx_tuple__8 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ __pyx_tuple__9 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__10 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__11 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ __pyx_tuple__12 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ __pyx_tuple__13 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ __pyx_tuple__14 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ __pyx_tuple__15 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_tuple__16 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ __pyx_tuple__17 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__18 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__19 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__19); __Pyx_GIVEREF(__pyx_tuple__19); /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__20 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ __pyx_tuple__21 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ __pyx_tuple__22 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__23 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__24 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ __pyx_tuple__25 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "src/llfuse/handlers.pxi":548 * IF TARGET_PLATFORM == 'freebsd': * # No known flags * with lock: # <<<<<<<<<<<<<< * operations.setxattr(ino, name, value) * ELSE: */ __pyx_tuple__26 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 548; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_tuple__27 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ __pyx_tuple__29 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__30 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ __pyx_tuple__31 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ __pyx_tuple__32 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); /* "src/llfuse/misc.pxi":79 * if not exc_info: * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') # <<<<<<<<<<<<<< * kill(getpid(), SIGTERM) * else: */ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_handler_raised_exception_sending); if (unlikely(!__pyx_tuple__33)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__33); __Pyx_GIVEREF(__pyx_tuple__33); /* "src/llfuse/misc.pxi":82 * kill(getpid(), SIGTERM) * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * if req is NULL: */ __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_Exception_after_kill); if (unlikely(!__pyx_tuple__34)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); /* "src/llfuse/misc.pxi":152 * for el in args: * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_fuse_options_must_be_of_type_str); if (unlikely(!__pyx_tuple__35)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); /* "src/llfuse/misc.pxi":154 * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) # <<<<<<<<<<<<<< * args = args_new * */ __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_us_ascii); if (unlikely(!__pyx_tuple__36)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); /* "src/llfuse/misc.pxi":192 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_u_You_should_not_instantiate_this); if (unlikely(!__pyx_tuple__37)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__37); __Pyx_GIVEREF(__pyx_tuple__37); /* "src/llfuse/misc.pxi":219 * return False * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_u_Global_lock_cannot_be_acquired_m); if (unlikely(!__pyx_tuple__38)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "src/llfuse/misc.pxi":221 * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_u_Lock_still_taken_after_receiving); if (unlikely(!__pyx_tuple__39)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__39); __Pyx_GIVEREF(__pyx_tuple__39); /* "src/llfuse/misc.pxi":223 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__40)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); /* "src/llfuse/misc.pxi":237 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_u_Lock_can_only_be_released_by_the); if (unlikely(!__pyx_tuple__41)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__41); __Pyx_GIVEREF(__pyx_tuple__41); /* "src/llfuse/misc.pxi":239 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__42)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__42); __Pyx_GIVEREF(__pyx_tuple__42); /* "src/llfuse/misc.pxi":261 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_Lock_can_only_be_released_by_the); if (unlikely(!__pyx_tuple__43)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); /* "src/llfuse/misc.pxi":263 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") */ __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_u_Lock_still_taken_after_receiving); if (unlikely(!__pyx_tuple__44)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__44); __Pyx_GIVEREF(__pyx_tuple__44); /* "src/llfuse/misc.pxi":265 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_Other_thread_didn_t_take_lock); if (unlikely(!__pyx_tuple__45)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__45); __Pyx_GIVEREF(__pyx_tuple__45); /* "src/llfuse/misc.pxi":267 * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__46)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__46); __Pyx_GIVEREF(__pyx_tuple__46); /* "src/llfuse/misc.pxi":282 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_You_should_not_instantiate_this); if (unlikely(!__pyx_tuple__47)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); /* "src/llfuse/fuse_api.pxi":28 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef dirent.DIR* dirp */ __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__48)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__48); __Pyx_GIVEREF(__pyx_tuple__48); /* "src/llfuse/fuse_api.pxi":82 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__51)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); /* "src/llfuse/fuse_api.pxi":85 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_name_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__52)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__52); __Pyx_GIVEREF(__pyx_tuple__52); /* "src/llfuse/fuse_api.pxi":144 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__53)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); /* "src/llfuse/fuse_api.pxi":147 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_u_name_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__54)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__54); __Pyx_GIVEREF(__pyx_tuple__54); /* "src/llfuse/fuse_api.pxi":231 * ''' * * log.debug('Initializing llfuse') # <<<<<<<<<<<<<< * cdef fuse_args f_args * */ __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_Initializing_llfuse); if (unlikely(!__pyx_tuple__55)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); /* "src/llfuse/fuse_api.pxi":235 * * if not isinstance(mountpoint, str_t): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_mountpoint__argument_must_be_of); if (unlikely(!__pyx_tuple__56)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); /* "src/llfuse/fuse_api.pxi":250 * * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') # <<<<<<<<<<<<<< * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: */ __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_mount); if (unlikely(!__pyx_tuple__57)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__57); __Pyx_GIVEREF(__pyx_tuple__57); /* "src/llfuse/fuse_api.pxi":253 * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: * raise RuntimeError('fuse_mount failed') # <<<<<<<<<<<<<< * * log.debug('Calling fuse_lowlevel_new') */ __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_u_fuse_mount_failed); if (unlikely(!__pyx_tuple__58)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); /* "src/llfuse/fuse_api.pxi":255 * raise RuntimeError('fuse_mount failed') * * log.debug('Calling fuse_lowlevel_new') # <<<<<<<<<<<<<< * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) */ __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_lowlevel_new); if (unlikely(!__pyx_tuple__59)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); /* "src/llfuse/fuse_api.pxi":260 * if not session: * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_set_signal_handlers') */ __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_u_fuse_lowlevel_new_failed); if (unlikely(!__pyx_tuple__60)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__60); __Pyx_GIVEREF(__pyx_tuple__60); /* "src/llfuse/fuse_api.pxi":262 * raise RuntimeError("fuse_lowlevel_new() failed") * * log.debug('Calling fuse_set_signal_handlers') # <<<<<<<<<<<<<< * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) */ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_set_signal_handlers); if (unlikely(!__pyx_tuple__61)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); /* "src/llfuse/fuse_api.pxi":266 * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_add_chan') */ __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_u_fuse_set_signal_handlers_failed); if (unlikely(!__pyx_tuple__62)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); /* "src/llfuse/fuse_api.pxi":268 * raise RuntimeError("fuse_set_signal_handlers() failed") * * log.debug('Calling fuse_session_add_chan') # <<<<<<<<<<<<<< * fuse_session_add_chan(session, channel) * */ __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_add_chan); if (unlikely(!__pyx_tuple__63)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); /* "src/llfuse/fuse_api.pxi":283 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * # Start notification handling thread */ __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_u_Need_to_call_init_before_main); if (unlikely(!__pyx_tuple__64)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); /* "src/llfuse/fuse_api.pxi":293 * * if single: * log.debug('Calling fuse_session_loop') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop(session) */ __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_loop); if (unlikely(!__pyx_tuple__65)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); /* "src/llfuse/fuse_api.pxi":296 * with nogil: * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop failed") */ __pyx_tuple__66 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__66)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__66); __Pyx_GIVEREF(__pyx_tuple__66); /* "src/llfuse/fuse_api.pxi":298 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop failed") # <<<<<<<<<<<<<< * else: * log.debug('Calling fuse_session_loop_mt') */ __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_loop_failed); if (unlikely(!__pyx_tuple__67)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); /* "src/llfuse/fuse_api.pxi":300 * raise RuntimeError("fuse_session_loop failed") * else: * log.debug('Calling fuse_session_loop_mt') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop_mt(session) */ __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_loop_mt); if (unlikely(!__pyx_tuple__68)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__68); __Pyx_GIVEREF(__pyx_tuple__68); /* "src/llfuse/fuse_api.pxi":303 * with nogil: * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") */ __pyx_tuple__69 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__69)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); /* "src/llfuse/fuse_api.pxi":305 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") # <<<<<<<<<<<<<< * * if exc_info: */ __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_loop_mt_failed); if (unlikely(!__pyx_tuple__70)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__70); __Pyx_GIVEREF(__pyx_tuple__70); /* "src/llfuse/fuse_api.pxi":309 * if exc_info: * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_Terminated_main_loop_because_req); if (unlikely(!__pyx_tuple__71)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); /* "src/llfuse/fuse_api.pxi":335 * global exc_info * * log.debug('Calling fuse_session_remove_chan') # <<<<<<<<<<<<<< * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') */ __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_remove_chan); if (unlikely(!__pyx_tuple__72)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__72); __Pyx_GIVEREF(__pyx_tuple__72); /* "src/llfuse/fuse_api.pxi":337 * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') # <<<<<<<<<<<<<< * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') */ __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_remove_signal_handl); if (unlikely(!__pyx_tuple__73)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__73); __Pyx_GIVEREF(__pyx_tuple__73); /* "src/llfuse/fuse_api.pxi":339 * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') # <<<<<<<<<<<<<< * fuse_session_destroy(session) * */ __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_destroy); if (unlikely(!__pyx_tuple__74)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__74); __Pyx_GIVEREF(__pyx_tuple__74); /* "src/llfuse/fuse_api.pxi":343 * * if unmount: * log.debug('Calling fuse_unmount') # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * else: */ __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_unmount); if (unlikely(!__pyx_tuple__75)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__75); __Pyx_GIVEREF(__pyx_tuple__75); /* "llfuse/capi.pyx":93 * ################## * * log = logging.getLogger("llfuse") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __pyx_tuple__76 = PyTuple_Pack(1, __pyx_n_u_llfuse); if (unlikely(!__pyx_tuple__76)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__76); __Pyx_GIVEREF(__pyx_tuple__76); /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ __pyx_tuple__77 = PyTuple_Pack(4, __pyx_n_s_len, __pyx_n_s_ino, __pyx_n_s_cname, __pyx_n_s_req); if (unlikely(!__pyx_tuple__77)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__77); __Pyx_GIVEREF(__pyx_tuple__77); __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(0, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho, __pyx_n_s_notify_loop, 291, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_tuple__79 = PyTuple_Pack(8, __pyx_n_s_path, __pyx_n_s_dirp, __pyx_n_s_ent, __pyx_n_s_res, __pyx_n_s_ret, __pyx_n_s_buf, __pyx_n_s_path_b, __pyx_n_s_names); if (unlikely(!__pyx_tuple__79)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__79); __Pyx_GIVEREF(__pyx_tuple__79); __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__79, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_listdir, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_tuple__81 = PyTuple_Pack(12, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_len, __pyx_n_s_cvalue, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_cnamespace, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__81)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__81); __Pyx_GIVEREF(__pyx_tuple__81); __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_setxattr, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_tuple__83 = PyTuple_Pack(12, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_size_guess, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_buf, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_bufsize, __pyx_n_s_cnamespace, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__83)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__83); __Pyx_GIVEREF(__pyx_tuple__83); __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__83, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_getxattr, 122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __pyx_tuple__85 = PyTuple_Pack(4, __pyx_n_s_ops, __pyx_n_s_mountpoint, __pyx_n_s_args, __pyx_n_s_f_args); if (unlikely(!__pyx_tuple__85)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__85); __Pyx_GIVEREF(__pyx_tuple__85); __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__85, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_init, 218, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ __pyx_tuple__87 = PyTuple_Pack(4, __pyx_n_s_single, __pyx_n_s_ret, __pyx_n_s_t, __pyx_n_s_tmp); if (unlikely(!__pyx_tuple__87)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__87); __Pyx_GIVEREF(__pyx_tuple__87); __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__87, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_main_2, 271, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ __pyx_tuple__89 = PyTuple_Pack(2, __pyx_n_s_unmount, __pyx_n_s_tmp); if (unlikely(!__pyx_tuple__89)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__89); __Pyx_GIVEREF(__pyx_tuple__89); __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__89, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_close, 321, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_tuple__91 = PyTuple_Pack(2, __pyx_n_s_inode, __pyx_n_s_attr_only); if (unlikely(!__pyx_tuple__91)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__91); __Pyx_GIVEREF(__pyx_tuple__91); __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__91, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_invalidate_inode, 365, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_tuple__93 = PyTuple_Pack(2, __pyx_n_s_inode_p, __pyx_n_s_name); if (unlikely(!__pyx_tuple__93)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__93); __Pyx_GIVEREF(__pyx_tuple__93); __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__93, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_invalidate_entry, 376, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_get_ino_t_bits, 387, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_get_off_t_bits, 395, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __pyx_float_1e9 = PyFloat_FromDouble(1e9); if (unlikely(!__pyx_float_1e9)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1000000000 = PyInt_FromLong(1000000000L); if (unlikely(!__pyx_int_1000000000)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC initcapi(void); /*proto*/ PyMODINIT_FUNC initcapi(void) #else PyMODINIT_FUNC PyInit_capi(void); /*proto*/ PyMODINIT_FUNC PyInit_capi(void) #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_capi(void)", 0); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("capi", __pyx_methods, __pyx_k_capi_pxy_Copyright_2013_Nikolau, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if (__pyx_module_is_main_llfuse__capi) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (!PyDict_GetItemString(modules, "llfuse.capi")) { if (unlikely(PyDict_SetItemString(modules, "llfuse.capi", __pyx_m) < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } #endif /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ __pyx_v_6llfuse_4capi_operations = Py_None; Py_INCREF(Py_None); __pyx_v_6llfuse_4capi_mountpoint_b = Py_None; Py_INCREF(Py_None); __pyx_v_6llfuse_4capi_exc_info = Py_None; Py_INCREF(Py_None); /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ if (PyType_Ready(&__pyx_type_6llfuse_4capi_Lock) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 185; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6llfuse_4capi_Lock.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "Lock", (PyObject *)&__pyx_type_6llfuse_4capi_Lock) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 185; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6llfuse_4capi_Lock = &__pyx_type_6llfuse_4capi_Lock; if (PyType_Ready(&__pyx_type_6llfuse_4capi_NoLockManager) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6llfuse_4capi_NoLockManager.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "NoLockManager", (PyObject *)&__pyx_type_6llfuse_4capi_NoLockManager) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6llfuse_4capi_NoLockManager = &__pyx_type_6llfuse_4capi_NoLockManager; /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "llfuse/capi.pyx":13 * cdef extern from *: * char* LLFUSE_VERSION * __version__ = LLFUSE_VERSION.decode('utf-8') # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_decode_c_string(LLFUSE_VERSION, 0, strlen(LLFUSE_VERSION), NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 13; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 13; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":74 * ################ * * import os # <<<<<<<<<<<<<< * import logging * import sys */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 74; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 74; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":75 * * import os * import logging # <<<<<<<<<<<<<< * import sys * import os.path */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_logging, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_logging, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":76 * import os * import logging * import sys # <<<<<<<<<<<<<< * import os.path * import threading */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":77 * import logging * import sys * import os.path # <<<<<<<<<<<<<< * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os_path, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":78 * import sys * import os.path * import threading # <<<<<<<<<<<<<< * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes * from collections import namedtuple */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_threading, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":79 * import os.path * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes # <<<<<<<<<<<<<< * from collections import namedtuple * */ __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_FUSEError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_FUSEError); __Pyx_GIVEREF(__pyx_n_s_FUSEError); __Pyx_INCREF(__pyx_n_s_strerror); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_strerror); __Pyx_GIVEREF(__pyx_n_s_strerror); __Pyx_INCREF(__pyx_n_s_Operations); PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_Operations); __Pyx_GIVEREF(__pyx_n_s_Operations); __Pyx_INCREF(__pyx_n_s_RequestContext); PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_RequestContext); __Pyx_GIVEREF(__pyx_n_s_RequestContext); __Pyx_INCREF(__pyx_n_s_EntryAttributes); PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_EntryAttributes); __Pyx_GIVEREF(__pyx_n_s_EntryAttributes); __pyx_t_2 = __Pyx_Import(__pyx_n_s_llfuse_pyapi, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FUSEError); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FUSEError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_strerror, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Operations); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Operations, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_RequestContext); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_RequestContext, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_EntryAttributes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_EntryAttributes, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":80 * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes * from collections import namedtuple # <<<<<<<<<<<<<< * * if PY_MAJOR_VERSION < 3: */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_namedtuple); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_namedtuple); __Pyx_GIVEREF(__pyx_n_s_namedtuple); __pyx_t_1 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_namedtuple); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_namedtuple, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":82 * from collections import namedtuple * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * from Queue import Queue * str_t = bytes */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "llfuse/capi.pyx":83 * * if PY_MAJOR_VERSION < 3: * from Queue import Queue # <<<<<<<<<<<<<< * str_t = bytes * else: */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Queue); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Queue); __Pyx_GIVEREF(__pyx_n_s_Queue); __pyx_t_2 = __Pyx_Import(__pyx_n_s_Queue, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Queue, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":84 * if PY_MAJOR_VERSION < 3: * from Queue import Queue * str_t = bytes # <<<<<<<<<<<<<< * else: * from queue import Queue */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_t, ((PyObject *)((PyObject*)(&PyBytes_Type)))) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L2; } /*else*/ { /* "llfuse/capi.pyx":86 * str_t = bytes * else: * from queue import Queue # <<<<<<<<<<<<<< * str_t = str * */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_Queue); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Queue); __Pyx_GIVEREF(__pyx_n_s_Queue); __pyx_t_1 = __Pyx_Import(__pyx_n_s_queue, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Queue, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":87 * else: * from queue import Queue * str_t = str # <<<<<<<<<<<<<< * * ################## */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_t, ((PyObject *)((PyObject*)(&PyUnicode_Type)))) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_L2:; /* "llfuse/capi.pyx":93 * ################## * * log = logging.getLogger("llfuse") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_logging); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getLogger); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_log, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":94 * * log = logging.getLogger("llfuse") * fse = sys.getfilesystemencoding() # <<<<<<<<<<<<<< * * cdef object operations */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getfilesystemencoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_fse, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":98 * cdef object operations * cdef object mountpoint_b * cdef fuse_session* session = NULL # <<<<<<<<<<<<<< * cdef fuse_chan* channel = NULL * cdef fuse_lowlevel_ops fuse_ops */ __pyx_v_6llfuse_4capi_session = NULL; /* "llfuse/capi.pyx":99 * cdef object mountpoint_b * cdef fuse_session* session = NULL * cdef fuse_chan* channel = NULL # <<<<<<<<<<<<<< * cdef fuse_lowlevel_ops fuse_ops * cdef object exc_info */ __pyx_v_6llfuse_4capi_channel = NULL; /* "llfuse/capi.pyx":103 * cdef object exc_info * * init_lock() # <<<<<<<<<<<<<< * lock = Lock.__new__(Lock) * lock_released = NoLockManager.__new__(NoLockManager) */ init_lock(); /* "llfuse/capi.pyx":104 * * init_lock() * lock = Lock.__new__(Lock) # <<<<<<<<<<<<<< * lock_released = NoLockManager.__new__(NoLockManager) * */ __pyx_t_1 = __pyx_tp_new_6llfuse_4capi_Lock(((PyTypeObject *)((PyObject*)__pyx_ptype_6llfuse_4capi_Lock)), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_lock, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":105 * init_lock() * lock = Lock.__new__(Lock) * lock_released = NoLockManager.__new__(NoLockManager) # <<<<<<<<<<<<<< * * _notify_queue = Queue(maxsize=1000) */ __pyx_t_1 = __pyx_tp_new_6llfuse_4capi_NoLockManager(((PyTypeObject *)((PyObject*)__pyx_ptype_6llfuse_4capi_NoLockManager)), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_lock_released, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":107 * lock_released = NoLockManager.__new__(NoLockManager) * * _notify_queue = Queue(maxsize=1000) # <<<<<<<<<<<<<< * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_maxsize, __pyx_int_1000) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_queue, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":108 * * _notify_queue = Queue(maxsize=1000) * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) # <<<<<<<<<<<<<< * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) * */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_namedtuple); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_inode); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_inode); __Pyx_GIVEREF(__pyx_n_u_inode); __Pyx_INCREF(__pyx_n_u_attr_only); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_u_attr_only); __Pyx_GIVEREF(__pyx_n_u_attr_only); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_n_u_inval_inode_req); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_n_u_inval_inode_req); __Pyx_GIVEREF(__pyx_n_u_inval_inode_req); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_inval_inode_req, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":109 * _notify_queue = Queue(maxsize=1000) * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) # <<<<<<<<<<<<<< * * # Exported for access from Python code */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_namedtuple); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = PyList_New(2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_n_u_inode_p); PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_u_inode_p); __Pyx_GIVEREF(__pyx_n_u_inode_p); __Pyx_INCREF(__pyx_n_u_name); PyList_SET_ITEM(__pyx_t_7, 1, __pyx_n_u_name); __Pyx_GIVEREF(__pyx_n_u_name); __pyx_t_1 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_1) { PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = NULL; } __Pyx_INCREF(__pyx_n_u_inval_entry_req); PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_n_u_inval_entry_req); __Pyx_GIVEREF(__pyx_n_u_inval_entry_req); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_inval_entry_req, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":112 * * # Exported for access from Python code * ROOT_INODE = FUSE_ROOT_ID # <<<<<<<<<<<<<< * ENOATTR = errno.ENOATTR * */ __pyx_t_2 = __Pyx_PyInt_From_int(FUSE_ROOT_ID); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROOT_INODE, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":113 * # Exported for access from Python code * ROOT_INODE = FUSE_ROOT_ID * ENOATTR = errno.ENOATTR # <<<<<<<<<<<<<< * * ####################### */ __pyx_t_2 = __Pyx_PyInt_From_int(ENOATTR); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENOATTR, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_1_notify_loop, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_loop, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_3listdir, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_listdir, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_5setxattr, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setxattr, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_7getxattr, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_getxattr, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_9init, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_init, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_11main, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_main_2, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_13close, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_close, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_15invalidate_inode, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_inode, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_17invalidate_entry, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_entry, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_19get_ino_t_bits, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_ino_t_bits, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_21get_off_t_bits, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_off_t_bits, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":1 * ''' # <<<<<<<<<<<<<< * capi.pxy * */ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init llfuse.capi", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init llfuse.capi"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif } /* Runtime support code */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule((char *)modname); if (!m) goto end; p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON result = PyDict_GetItem(__pyx_d, name); if (likely(result)) { Py_INCREF(result); } else { #else result = PyObject_GetItem(__pyx_d, name); if (!result) { PyErr_Clear(); #endif result = __Pyx_GetBuiltinName(name); } return result; } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject* args = PyTuple_Pack(1, arg); return (likely(args)) ? __Pyx_PyObject_Call(func, args, NULL) : NULL; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else PyErr_GetExcInfo(type, value, tb); #endif } static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(type, value, tb); #endif } static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { PyObject *local_type, *local_value, *local_tb; #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_COMPILING_IN_CPYTHON tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_Restore(type, value, tb); #endif } static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(type, value, tb); #endif } static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } } static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #else PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } #if !CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); } #endif #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { if (PyObject_IsSubclass(instance_class, type)) { type = instance_class; } else { instance_class = NULL; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } #if PY_VERSION_HEX >= 0x03030000 if (cause) { #else if (cause && cause != Py_None) { #endif PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(tmp_type, tmp_value, tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = PyThreadState_GET(); PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } static CYTHON_INLINE int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); } static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (none_allowed && obj == Py_None) return 1; else if (exact) { if (likely(Py_TYPE(obj) == type)) return 1; #if PY_MAJOR_VERSION == 2 else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(PyObject_TypeCheck(obj, type))) return 1; } __Pyx_RaiseArgumentTypeInvalid(name, obj, type); return 0; } static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_Clear(); else return NULL; } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { Py_ssize_t length; if (unlikely((start < 0) | (stop < 0))) { length = strlen(cstring); if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; } length = stop - start; if (unlikely(length <= 0)) return PyUnicode_FromUnicode(NULL, 0); cstring += start; if (decode_func) { return decode_func(cstring, length, errors); } else { return PyUnicode_Decode(cstring, length, encoding, errors); } } static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = (start + end) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; py_code = __pyx_find_code_object(c_line ? c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? c_line : py_line, py_code); } py_frame = PyFrame_New( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; py_frame->f_lineno = py_line; PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_VERSION_HEX < 0x03030000 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(1); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); #endif if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_VERSION_HEX < 0x03030000 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(int) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value) \ { \ func_type value = func_value; \ if (sizeof(target_type) < sizeof(func_type)) { \ if (unlikely(value != (func_type) (target_type) value)) { \ func_type zero = 0; \ if (is_unsigned && unlikely(value < zero)) \ goto raise_neg_overflow; \ else \ goto raise_overflow; \ } \ } \ return (target_type) value; \ } #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #endif #endif static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(int) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyLong_AsLong(x)) } else if (sizeof(int) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(int, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value) { const fuse_ino_t neg_one = (fuse_ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(fuse_ino_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(fuse_ino_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fuse_ino_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(fuse_ino_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) { const unsigned long neg_one = (unsigned long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(unsigned long) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(unsigned long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned long) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(unsigned long), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(long) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value) { const time_t neg_one = (time_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(time_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(time_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(time_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(time_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(time_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(time_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value) { const mode_t neg_one = (mode_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(mode_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(mode_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(mode_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(mode_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(mode_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(mode_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value) { const uid_t neg_one = (uid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uid_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value) { const gid_t neg_one = (gid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(gid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(gid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(gid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(gid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(gid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(gid_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value) { const off_t neg_one = (off_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(off_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(off_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(off_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(off_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(off_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(off_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value) { const dev_t neg_one = (dev_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(dev_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(dev_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(dev_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(dev_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(dev_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(dev_t), little, !is_unsigned); } } static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) { const uint64_t neg_one = (uint64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uint64_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint64_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(uint64_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(uint64_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(uint64_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long, PyLong_AsLong(x)) } else if (sizeof(uint64_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uint64_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uint64_t) -1; } } else { uint64_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (uint64_t) -1; val = __Pyx_PyInt_As_uint64_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint64_t"); return (uint64_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint64_t"); return (uint64_t) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) { const uint64_t neg_one = (uint64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint64_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uint64_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uint64_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint64_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uint64_t), little, !is_unsigned); } } static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { const size_t neg_one = (size_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(size_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (size_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(size_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(size_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(size_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyLong_AsLong(x)) } else if (sizeof(size_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(size_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else size_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (size_t) -1; } } else { size_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (size_t) -1; val = __Pyx_PyInt_As_size_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to size_t"); return (size_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to size_t"); return (size_t) -1; } static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *x) { const off_t neg_one = (off_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(off_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(off_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (off_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(off_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(off_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(off_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(off_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(off_t, long, PyLong_AsLong(x)) } else if (sizeof(off_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(off_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else off_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (off_t) -1; } } else { off_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (off_t) -1; val = __Pyx_PyInt_As_off_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to off_t"); return (off_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to off_t"); return (off_t) -1; } static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *x) { const fuse_ino_t neg_one = (fuse_ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fuse_ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fuse_ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fuse_ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, PyLong_AsLong(x)) } else if (sizeof(fuse_ino_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fuse_ino_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fuse_ino_t) -1; } } else { fuse_ino_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fuse_ino_t) -1; val = __Pyx_PyInt_As_fuse_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fuse_ino_t"); return (fuse_ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fuse_ino_t"); return (fuse_ino_t) -1; } static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) { const unsigned long neg_one = (unsigned long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(unsigned long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(unsigned long) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(unsigned long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyLong_AsLong(x)) } else if (sizeof(unsigned long) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned long val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned long) -1; } } else { unsigned long val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (unsigned long) -1; val = __Pyx_PyInt_As_unsigned_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned long"); return (unsigned long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned long"); return (unsigned long) -1; } static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *x) { const ino_t neg_one = (ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(ino_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(ino_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(ino_t, long, PyLong_AsLong(x)) } else if (sizeof(ino_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(ino_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else ino_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (ino_t) -1; } } else { ino_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (ino_t) -1; val = __Pyx_PyInt_As_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to ino_t"); return (ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to ino_t"); return (ino_t) -1; } static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *x) { const mode_t neg_one = (mode_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(mode_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(mode_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (mode_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(mode_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(mode_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(mode_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(mode_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(mode_t, long, PyLong_AsLong(x)) } else if (sizeof(mode_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(mode_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else mode_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (mode_t) -1; } } else { mode_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (mode_t) -1; val = __Pyx_PyInt_As_mode_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to mode_t"); return (mode_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to mode_t"); return (mode_t) -1; } static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *x) { const nlink_t neg_one = (nlink_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(nlink_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (nlink_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(nlink_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(nlink_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(nlink_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(nlink_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long, PyLong_AsLong(x)) } else if (sizeof(nlink_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else nlink_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (nlink_t) -1; } } else { nlink_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (nlink_t) -1; val = __Pyx_PyInt_As_nlink_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to nlink_t"); return (nlink_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to nlink_t"); return (nlink_t) -1; } static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *x) { const uid_t neg_one = (uid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(uid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(uid_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(uid_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(uid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(uid_t, long, PyLong_AsLong(x)) } else if (sizeof(uid_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(uid_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uid_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uid_t) -1; } } else { uid_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (uid_t) -1; val = __Pyx_PyInt_As_uid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uid_t"); return (uid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uid_t"); return (uid_t) -1; } static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *x) { const gid_t neg_one = (gid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(gid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(gid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (gid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(gid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(gid_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(gid_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(gid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(gid_t, long, PyLong_AsLong(x)) } else if (sizeof(gid_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(gid_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else gid_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (gid_t) -1; } } else { gid_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (gid_t) -1; val = __Pyx_PyInt_As_gid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to gid_t"); return (gid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to gid_t"); return (gid_t) -1; } static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *x) { const dev_t neg_one = (dev_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(dev_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(dev_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (dev_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(dev_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(dev_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(dev_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(dev_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(dev_t, long, PyLong_AsLong(x)) } else if (sizeof(dev_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(dev_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else dev_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (dev_t) -1; } } else { dev_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (dev_t) -1; val = __Pyx_PyInt_As_dev_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to dev_t"); return (dev_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to dev_t"); return (dev_t) -1; } static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *x) { const blksize_t neg_one = (blksize_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blksize_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blksize_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(blksize_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(blksize_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(blksize_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(blksize_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long, PyLong_AsLong(x)) } else if (sizeof(blksize_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blksize_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blksize_t) -1; } } else { blksize_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (blksize_t) -1; val = __Pyx_PyInt_As_blksize_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blksize_t"); return (blksize_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blksize_t"); return (blksize_t) -1; } static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *x) { const blkcnt_t neg_one = (blkcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(blkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(blkcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(blkcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(blkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(blkcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blkcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blkcnt_t) -1; } } else { blkcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (blkcnt_t) -1; val = __Pyx_PyInt_As_blkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blkcnt_t"); return (blkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blkcnt_t"); return (blkcnt_t) -1; } static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) { const time_t neg_one = (time_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(time_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(time_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (time_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(time_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(time_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(time_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(time_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(time_t, long, PyLong_AsLong(x)) } else if (sizeof(time_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(time_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else time_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (time_t) -1; } } else { time_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (time_t) -1; val = __Pyx_PyInt_As_time_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to time_t"); return (time_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to time_t"); return (time_t) -1; } static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(long) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyLong_AsLong(x)) } else if (sizeof(long) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(long, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *x) { const fsblkcnt_t neg_one = (fsblkcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsblkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsblkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fsblkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fsblkcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fsblkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(fsblkcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsblkcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsblkcnt_t) -1; } } else { fsblkcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fsblkcnt_t) -1; val = __Pyx_PyInt_As_fsblkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsblkcnt_t"); return (fsblkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsblkcnt_t"); return (fsblkcnt_t) -1; } static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *x) { const fsfilcnt_t neg_one = (fsfilcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsfilcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsfilcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fsfilcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fsfilcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fsfilcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(fsfilcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsfilcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsfilcnt_t) -1; } } else { fsfilcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fsfilcnt_t) -1; val = __Pyx_PyInt_As_fsfilcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsfilcnt_t"); return (fsfilcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsfilcnt_t"); return (fsfilcnt_t) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value) { const pid_t neg_one = (pid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(pid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(pid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(pid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(pid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(pid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(pid_t), little, !is_unsigned); } } static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { #if PY_VERSION_HEX < 0x03030000 char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; #else if (__Pyx_PyUnicode_READY(o) == -1) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (PyUnicode_IS_ASCII(o)) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif #endif } else #endif #if !CYTHON_COMPILING_IN_PYPY if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { PyNumberMethods *m; const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(x) || PyLong_Check(x)) #else if (PyLong_Check(x)) #endif return Py_INCREF(x), x; m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = PyNumber_Int(x); } else if (m && m->nb_long) { name = "long"; res = PyNumber_Long(x); } #else if (m && m->nb_int) { name = "int"; res = PyNumber_Long(x); } #endif if (res) { #if PY_MAJOR_VERSION < 3 if (!PyInt_Check(res) && !PyLong_Check(res)) { #else if (!PyLong_Check(res)) { #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", name, name, Py_TYPE(res)->tp_name); Py_DECREF(res); return NULL; } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) return PyInt_AS_LONG(b); #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(b)) { case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0]; case 0: return 0; case 1: return ((PyLongObject*)b)->ob_digit[0]; } #endif #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ llfuse-0.41.1/src/llfuse/capi_linux.c0000664000175000017500000525772212566230167021167 0ustar nikrationikratio00000000000000/* Generated by Cython 0.21.1 */ #define PY_SSIZE_T_CLEAN #ifndef CYTHON_USE_PYLONG_INTERNALS #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 0 #else #include "pyconfig.h" #ifdef PYLONG_BITS_IN_DIGIT #define CYTHON_USE_PYLONG_INTERNALS 1 #else #define CYTHON_USE_PYLONG_INTERNALS 0 #endif #endif #endif #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) #error Cython requires Python 2.6+ or Python 3.2+. #else #define CYTHON_ABI "0_21_1" #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyType_Type #endif #if PY_MAJOR_VERSION >= 3 #define Py_TPFLAGS_CHECKTYPES 0 #define Py_TPFLAGS_HAVE_INDEX 0 #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #if PY_VERSION_HEX < 0x030400a1 && !defined(Py_TPFLAGS_HAVE_FINALIZE) #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #else #define CYTHON_PEP393_ENABLED 0 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #define __Pyx_PyFrozenSet_Size(s) PyObject_Size(s) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #define __Pyx_PyFrozenSet_Size(s) PySet_Size(s) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #ifndef CYTHON_INLINE #if defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is a quiet NaN. */ float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #ifdef __cplusplus template void __Pyx_call_destructor(T* x) { x->~T(); } #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #define __PYX_HAVE__llfuse__capi #define __PYX_HAVE_API__llfuse__capi #include "fuse_opt.h" #include "stdint.h" #include "sys/types.h" #include "sys/stat.h" #include "sys/statvfs.h" #include "string.h" #include "stdlib.h" #include "fuse_lowlevel.h" #include "errno.h" #include "dirent.h" #include "attr/xattr.h" #include "unistd.h" #include "signal.h" #include "sys/time.h" #include "lock.c" #include "time.c" #include "version.c" #ifdef _OPENMP #include #endif /* _OPENMP */ #ifdef PYREX_WITHOUT_ASSERTIONS #define CYTHON_WITHOUT_ASSERTIONS #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ (sizeof(type) < sizeof(Py_ssize_t)) || \ (sizeof(type) > sizeof(Py_ssize_t) && \ likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX) && \ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ v == (type)PY_SSIZE_T_MIN))) || \ (sizeof(type) == sizeof(Py_ssize_t) && \ (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromUString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((const char*)s) #if PY_MAJOR_VERSION < 3 static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #else #define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen #endif #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) #define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_COMPILING_IN_CPYTHON #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static PyObject *__pyx_m; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "llfuse/handlers.pxi", "llfuse/misc.pxi", "llfuse/fuse_api.pxi", "llfuse/capi.pyx", }; /*--- Type declarations ---*/ struct __pyx_obj_6llfuse_4capi_Lock; struct __pyx_obj_6llfuse_4capi_NoLockManager; /* "src/llfuse/misc.pxi":185 * raise * * cdef class Lock: # <<<<<<<<<<<<<< * ''' * This is the class of lock itself as well as a context manager to */ struct __pyx_obj_6llfuse_4capi_Lock { PyObject_HEAD }; /* "src/llfuse/misc.pxi":278 * * * cdef class NoLockManager: # <<<<<<<<<<<<<< * '''Context manager to execute code while the global lock is released''' * */ struct __pyx_obj_6llfuse_4capi_NoLockManager { PyObject_HEAD }; #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil) \ if (acquire_gil) { \ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ PyGILState_Release(__pyx_gilstate_save); \ } else { \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil) \ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext() \ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_XDECREF(tmp); \ } while (0) #define __Pyx_DECREF_SET(r, v) do { \ PyObject *tmp = (PyObject *) r; \ r = v; __Pyx_DECREF(tmp); \ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name); #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) { PyObject *res; PyTypeObject *tp = Py_TYPE(obj); #if PY_MAJOR_VERSION < 3 if (unlikely(PyInstance_Check(obj))) return __Pyx_PyObject_GetAttrStr(obj, attr_name); #endif res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #else #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback); static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); static CYTHON_INLINE int __Pyx_IterFinish(void); static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyString_Join __Pyx_PyBytes_Join #define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) #else #define __Pyx_PyString_Join PyUnicode_Join #define __Pyx_PyBaseString_Join PyUnicode_Join #endif #if CYTHON_COMPILING_IN_CPYTHON #if PY_MAJOR_VERSION < 3 #define __Pyx_PyBytes_Join _PyString_Join #else #define __Pyx_PyBytes_Join _PyBytes_Join #endif #else static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); Py_SIZE(list) = len+1; return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[], \ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, \ const char* function_name); static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact); #include static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) : \ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) : \ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); typedef struct { int code_line; PyCodeObject* code_object; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value); static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *); static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *); static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *); static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *); static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *); static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *); static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *); static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *); static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *); static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *); static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *); static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *); static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *); static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *); static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value); static int __Pyx_check_binary_version(void); static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); /* Module declarations from 'fuse_opt' */ /* Module declarations from 'libc.stdint' */ /* Module declarations from 'fuse_common' */ /* Module declarations from 'libc.sys.types' */ /* Module declarations from 'libc.sys.stat' */ /* Module declarations from 'libc.sys.statvfs' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdlib' */ /* Module declarations from 'fuse_lowlevel' */ /* Module declarations from 'libc' */ /* Module declarations from 'libc.errno' */ /* Module declarations from 'libc.dirent' */ /* Module declarations from 'libc.xattr' */ /* Module declarations from 'posix.types' */ /* Module declarations from 'posix.unistd' */ /* Module declarations from 'posix.signal' */ /* Module declarations from 'posix.time' */ /* Module declarations from 'cpython.ref' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.version' */ /* Module declarations from 'llfuse.capi' */ static PyTypeObject *__pyx_ptype_6llfuse_4capi_Lock = 0; static PyTypeObject *__pyx_ptype_6llfuse_4capi_NoLockManager = 0; static PyObject *__pyx_v_6llfuse_4capi_operations = 0; static PyObject *__pyx_v_6llfuse_4capi_mountpoint_b = 0; static struct fuse_session *__pyx_v_6llfuse_4capi_session; static struct fuse_chan *__pyx_v_6llfuse_4capi_channel; static struct fuse_lowlevel_ops __pyx_v_6llfuse_4capi_fuse_ops; static PyObject *__pyx_v_6llfuse_4capi_exc_info = 0; static void __pyx_f_6llfuse_4capi_fuse_init(void *, struct fuse_conn_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_destroy(void *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_lookup(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_forget(fuse_req_t, fuse_ino_t, unsigned long); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_getattr(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_setattr(fuse_req_t, fuse_ino_t, struct stat *, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_readlink(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_mknod(fuse_req_t, fuse_ino_t, const char *, mode_t, dev_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_mkdir(fuse_req_t, fuse_ino_t, const char *, mode_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_unlink(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_rmdir(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_symlink(fuse_req_t, const char *, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_rename(fuse_req_t, fuse_ino_t, const char *, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_link(fuse_req_t, fuse_ino_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_open(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_read(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_write(fuse_req_t, fuse_ino_t, const char *, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_flush(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_release(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_fsync(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_opendir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_readdir(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_releasedir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_fsyncdir(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_statfs(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_setxattr(fuse_req_t, fuse_ino_t, const char *, const char *, size_t, int); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_getxattr(fuse_req_t, fuse_ino_t, const char *, size_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_listxattr(fuse_req_t, fuse_ino_t, size_t); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_removexattr(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_access(fuse_req_t, fuse_ino_t, int); /*proto*/ static void __pyx_f_6llfuse_4capi_fuse_create(fuse_req_t, fuse_ino_t, const char *, mode_t, struct fuse_file_info *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_entry_param(PyObject *, struct fuse_entry_param *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_c_stat(PyObject *, struct stat *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_fill_statvfs(PyObject *, struct statvfs *); /*proto*/ static int __pyx_f_6llfuse_4capi_handle_exc(char *, PyObject *, fuse_req_t); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_get_request_context(fuse_req_t); /*proto*/ static void __pyx_f_6llfuse_4capi_init_fuse_ops(void); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_make_fuse_args(PyObject *, struct fuse_args *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_str2bytes(PyObject *); /*proto*/ static PyObject *__pyx_f_6llfuse_4capi_bytes2str(PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "llfuse.capi" int __pyx_module_is_main_llfuse__capi = 0; /* Implementation of 'llfuse.capi' */ static PyObject *__pyx_builtin_BaseException; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_OSError; static int __pyx_pf_6llfuse_4capi_4Lock___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_2acquire(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_timeout); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_4release(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_6yield_(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_count); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_8__enter__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4Lock_10__exit__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb); /* proto */ static int __pyx_pf_6llfuse_4capi_13NoLockManager___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_a); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi__notify_loop(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_2listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_4setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_6getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, int __pyx_v_size_guess, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_8init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_args); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_10main(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_single); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_12close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_14invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode, PyObject *__pyx_v_attr_only); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_16invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode_p, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_18get_ino_t_bits(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_6llfuse_4capi_20get_off_t_bits(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_tp_new_6llfuse_4capi_Lock(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_6llfuse_4capi_NoLockManager(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static char __pyx_k_o[] = "-o"; static char __pyx_k_t[] = "t"; static char __pyx_k_os[] = "os"; static char __pyx_k__28[] = "\000"; static char __pyx_k__49[] = "."; static char __pyx_k__50[] = ".."; static char __pyx_k_buf[] = "buf"; static char __pyx_k_ent[] = "ent"; static char __pyx_k_fse[] = "fse"; static char __pyx_k_get[] = "get"; static char __pyx_k_gid[] = "gid"; static char __pyx_k_ino[] = "ino"; static char __pyx_k_len[] = "len_"; static char __pyx_k_log[] = "log"; static char __pyx_k_ops[] = "ops"; static char __pyx_k_pid[] = "pid"; static char __pyx_k_put[] = "put"; static char __pyx_k_req[] = "req"; static char __pyx_k_res[] = "res"; static char __pyx_k_ret[] = "ret"; static char __pyx_k_sys[] = "sys"; static char __pyx_k_tmp[] = "tmp"; static char __pyx_k_uid[] = "uid"; static char __pyx_k_args[] = "args"; static char __pyx_k_dirp[] = "dirp"; static char __pyx_k_exit[] = "__exit__"; static char __pyx_k_init[] = "init"; static char __pyx_k_join[] = "join"; static char __pyx_k_link[] = "link"; static char __pyx_k_lock[] = "lock"; static char __pyx_k_main[] = "__main__"; static char __pyx_k_name[] = "name"; static char __pyx_k_open[] = "open"; static char __pyx_k_path[] = "path"; static char __pyx_k_read[] = "read"; static char __pyx_k_test[] = "__test__"; static char __pyx_k_user[] = "user"; static char __pyx_k_Queue[] = "Queue"; static char __pyx_k_block[] = "block"; static char __pyx_k_close[] = "close"; static char __pyx_k_cname[] = "cname"; static char __pyx_k_count[] = "count"; static char __pyx_k_cpath[] = "cpath"; static char __pyx_k_debug[] = "debug"; static char __pyx_k_enter[] = "__enter__"; static char __pyx_k_errno[] = "errno"; static char __pyx_k_error[] = "error"; static char __pyx_k_flush[] = "flush"; static char __pyx_k_fsync[] = "fsync"; static char __pyx_k_inode[] = "inode"; static char __pyx_k_mkdir[] = "mkdir"; static char __pyx_k_mknod[] = "mknod"; static char __pyx_k_names[] = "names"; static char __pyx_k_queue[] = "queue"; static char __pyx_k_range[] = "range"; static char __pyx_k_rmdir[] = "rmdir"; static char __pyx_k_start[] = "start"; static char __pyx_k_str_t[] = "str_t"; static char __pyx_k_umask[] = "umask"; static char __pyx_k_value[] = "value"; static char __pyx_k_write[] = "write"; static char __pyx_k_Thread[] = "Thread"; static char __pyx_k_access[] = "access"; static char __pyx_k_create[] = "create"; static char __pyx_k_cvalue[] = "cvalue"; static char __pyx_k_daemon[] = "daemon"; static char __pyx_k_decode[] = "decode"; static char __pyx_k_encode[] = "encode"; static char __pyx_k_exc_tb[] = "exc_tb"; static char __pyx_k_f_args[] = "f_args"; static char __pyx_k_forget[] = "forget"; static char __pyx_k_import[] = "__import__"; static char __pyx_k_llfuse[] = "llfuse"; static char __pyx_k_lookup[] = "lookup"; static char __pyx_k_main_2[] = "main"; static char __pyx_k_name_b[] = "name_b"; static char __pyx_k_path_b[] = "path_b"; static char __pyx_k_rename[] = "rename"; static char __pyx_k_single[] = "single"; static char __pyx_k_st_gid[] = "st_gid"; static char __pyx_k_st_ino[] = "st_ino"; static char __pyx_k_st_uid[] = "st_uid"; static char __pyx_k_statfs[] = "statfs"; static char __pyx_k_system[] = "system"; static char __pyx_k_target[] = "target"; static char __pyx_k_unlink[] = "unlink"; static char __pyx_k_ENOATTR[] = "ENOATTR"; static char __pyx_k_OSError[] = "OSError"; static char __pyx_k_abspath[] = "abspath"; static char __pyx_k_acquire[] = "acquire"; static char __pyx_k_bufsize[] = "bufsize"; static char __pyx_k_destroy[] = "destroy"; static char __pyx_k_exc_val[] = "exc_val"; static char __pyx_k_f_bfree[] = "f_bfree"; static char __pyx_k_f_bsize[] = "f_bsize"; static char __pyx_k_f_ffree[] = "f_ffree"; static char __pyx_k_f_files[] = "f_files"; static char __pyx_k_getattr[] = "getattr"; static char __pyx_k_inode_p[] = "inode_p"; static char __pyx_k_listdir[] = "listdir"; static char __pyx_k_logging[] = "logging"; static char __pyx_k_maxsize[] = "maxsize"; static char __pyx_k_opendir[] = "opendir"; static char __pyx_k_os_path[] = "os.path"; static char __pyx_k_readdir[] = "readdir"; static char __pyx_k_release[] = "release"; static char __pyx_k_setattr[] = "setattr"; static char __pyx_k_st_mode[] = "st_mode"; static char __pyx_k_st_rdev[] = "st_rdev"; static char __pyx_k_st_size[] = "st_size"; static char __pyx_k_symlink[] = "symlink"; static char __pyx_k_timeout[] = "timeout"; static char __pyx_k_unmount[] = "unmount"; static char __pyx_k_version[] = "__version__"; static char __pyx_k_exc_info[] = "exc_info"; static char __pyx_k_exc_type[] = "exc_type"; static char __pyx_k_f_bavail[] = "f_bavail"; static char __pyx_k_f_blocks[] = "f_blocks"; static char __pyx_k_f_favail[] = "f_favail"; static char __pyx_k_f_frsize[] = "f_frsize"; static char __pyx_k_fsyncdir[] = "fsyncdir"; static char __pyx_k_getxattr[] = "getxattr"; static char __pyx_k_readlink[] = "readlink"; static char __pyx_k_setxattr[] = "setxattr"; static char __pyx_k_st_atime[] = "st_atime"; static char __pyx_k_st_ctime[] = "st_ctime"; static char __pyx_k_st_mtime[] = "st_mtime"; static char __pyx_k_st_nlink[] = "st_nlink"; static char __pyx_k_strerror[] = "strerror"; static char __pyx_k_us_ascii[] = "us-ascii"; static char __pyx_k_FUSEError[] = "FUSEError"; static char __pyx_k_TypeError[] = "TypeError"; static char __pyx_k_attr_only[] = "attr_only"; static char __pyx_k_enumerate[] = "enumerate"; static char __pyx_k_exception[] = "exception"; static char __pyx_k_getLogger[] = "getLogger"; static char __pyx_k_listxattr[] = "listxattr"; static char __pyx_k_namespace[] = "namespace"; static char __pyx_k_st_blocks[] = "st_blocks"; static char __pyx_k_threading[] = "threading"; static char __pyx_k_Operations[] = "Operations"; static char __pyx_k_ROOT_INODE[] = "ROOT_INODE"; static char __pyx_k_ValueError[] = "ValueError"; static char __pyx_k_generation[] = "generation"; static char __pyx_k_mountpoint[] = "mountpoint"; static char __pyx_k_namedtuple[] = "namedtuple"; static char __pyx_k_releasedir[] = "releasedir"; static char __pyx_k_size_guess[] = "size_guess"; static char __pyx_k_st_blksize[] = "st_blksize"; static char __pyx_k_stacktrace[] = "stacktrace"; static char __pyx_k_collections[] = "collections"; static char __pyx_k_llfuse_capi[] = "llfuse.capi"; static char __pyx_k_notify_loop[] = "_notify_loop"; static char __pyx_k_removexattr[] = "removexattr"; static char __pyx_k_st_atime_ns[] = "st_atime_ns"; static char __pyx_k_st_ctime_ns[] = "st_ctime_ns"; static char __pyx_k_st_mtime_ns[] = "st_mtime_ns"; static char __pyx_k_RuntimeError[] = "RuntimeError"; static char __pyx_k_attr_timeout[] = "attr_timeout"; static char __pyx_k_llfuse_pyapi[] = "llfuse.pyapi"; static char __pyx_k_notify_queue[] = "_notify_queue"; static char __pyx_k_BaseException[] = "BaseException"; static char __pyx_k_Python_LLFUSE[] = "Python-LLFUSE"; static char __pyx_k_entry_timeout[] = "entry_timeout"; static char __pyx_k_lock_released[] = "lock_released"; static char __pyx_k_RequestContext[] = "RequestContext"; static char __pyx_k_get_ino_t_bits[] = "get_ino_t_bits"; static char __pyx_k_get_off_t_bits[] = "get_off_t_bits"; static char __pyx_k_with_traceback[] = "with_traceback"; static char __pyx_k_EntryAttributes[] = "EntryAttributes"; static char __pyx_k_fuse_stacktrace[] = "fuse_stacktrace"; static char __pyx_k_inval_entry_req[] = "inval_entry_req"; static char __pyx_k_inval_inode_req[] = "inval_inode_req"; static char __pyx_k_surrogateescape[] = "surrogateescape"; static char __pyx_k_invalidate_entry[] = "invalidate_entry"; static char __pyx_k_invalidate_inode[] = "invalidate_inode"; static char __pyx_k_unknown_flag_s_o[] = "unknown flag(s): %o"; static char __pyx_k_fuse_mount_failed[] = "fuse_mount failed"; static char __pyx_k_Calling_fuse_mount[] = "Calling fuse_mount"; static char __pyx_k_Initializing_llfuse[] = "Initializing llfuse"; static char __pyx_k_Calling_fuse_unmount[] = "Calling fuse_unmount"; static char __pyx_k_Exception_after_kill[] = "Exception after kill:"; static char __pyx_k_Lock_not_initialized[] = "Lock not initialized"; static char __pyx_k_getfilesystemencoding[] = "getfilesystemencoding"; static char __pyx_k_Weird_request_received_r[] = "Weird request received: %r"; static char __pyx_k_fuse_lowlevel_new_failed[] = "fuse_lowlevel_new() failed"; static char __pyx_k_fuse_session_loop_failed[] = "fuse_session_loop failed"; static char __pyx_k_Calling_fuse_lowlevel_new[] = "Calling fuse_lowlevel_new"; static char __pyx_k_Calling_fuse_session_loop[] = "Calling fuse_session_loop"; static char __pyx_k_fuse_session_loop_mt_failed[] = "fuse_session_loop_mt() failed"; static char __pyx_k_Calling_fuse_session_destroy[] = "Calling fuse_session_destroy"; static char __pyx_k_Calling_fuse_session_loop_mt[] = "Calling fuse_session_loop_mt"; static char __pyx_k_Calling_fuse_session_add_chan[] = "Calling fuse_session_add_chan"; static char __pyx_k_Need_to_call_init_before_main[] = "Need to call init() before main()"; static char __pyx_k_Other_thread_didn_t_take_lock[] = "Other thread didn't take lock"; static char __pyx_k_You_should_not_instantiate_this[] = "You should not instantiate this class, use the provided instance instead."; static char __pyx_k_capi_pxy_Copyright_2013_Nikolau[] = "\ncapi.pxy\n\nCopyright \302\251 2013 Nikolaus Rath \n\nThis file is part of Python-LLFUSE. This work may be distributed under\nthe terms of the GNU LGPL.\n"; static char __pyx_k_fuse_getattr_fuse_reply__failed[] = "fuse_getattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_opendir_fuse_reply__failed[] = "fuse_opendir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_readdir_fuse_reply__failed[] = "fuse_readdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_release_fuse_reply__failed[] = "fuse_release(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_set_signal_handlers_failed[] = "fuse_set_signal_handlers() failed"; static char __pyx_k_fuse_setattr_fuse_reply__failed[] = "fuse_setattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_symlink_fuse_reply__failed[] = "fuse_symlink(): fuse_reply_* failed with %s"; static char __pyx_k_home_nikratio_in_progress_pytho[] = "/home/nikratio/in-progress/python-llfuse/src/llfuse/misc.pxi"; static char __pyx_k_mountpoint__argument_must_be_of[] = "*mountpoint_* argument must be of type str"; static char __pyx_k_name_argument_must_be_of_type_s[] = "*name* argument must be of type str"; static char __pyx_k_namespace_parameter_must_be_sys[] = "*namespace* parameter must be \"system\" or \"user\", not %s"; static char __pyx_k_path_argument_must_be_of_type_s[] = "*path* argument must be of type str"; static char __pyx_k_Calling_fuse_remove_signal_handl[] = "Calling fuse_remove_signal_handlers"; static char __pyx_k_Calling_fuse_session_remove_chan[] = "Calling fuse_session_remove_chan"; static char __pyx_k_Calling_fuse_set_signal_handlers[] = "Calling fuse_set_signal_handlers"; static char __pyx_k_Global_lock_cannot_be_acquired_m[] = "Global lock cannot be acquired more than once"; static char __pyx_k_Lock_can_only_be_released_by_the[] = "Lock can only be released by the holding thread"; static char __pyx_k_Lock_still_taken_after_receiving[] = "Lock still taken after receiving unlock notification"; static char __pyx_k_Terminated_main_loop_because_req[] = "Terminated main loop because request handler raised exception, re-raising.."; static char __pyx_k_fuse_access_fuse_reply__failed_w[] = "fuse_access(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_create_fuse_reply__failed_w[] = "fuse_create(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_flush_fuse_reply__failed_wi[] = "fuse_flush(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_fsync_fuse_reply__failed_wi[] = "fuse_fsync(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_fsyncdir_fuse_reply__failed[] = "fuse_fsyncdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_getxattr_fuse_reply__failed[] = "fuse_getxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_link_fuse_reply__failed_wit[] = "fuse_link(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_listxattr_fuse_reply__faile[] = "fuse_listxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_lookup_fuse_reply__failed_w[] = "fuse_lookup(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_mkdir_fuse_reply__failed_wi[] = "fuse_mkdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_mknod_fuse_reply__failed_wi[] = "fuse_mknod(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_options_must_be_of_type_str[] = "fuse options must be of type str"; static char __pyx_k_fuse_read_fuse_reply__failed_wit[] = "fuse_read(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_readlink_fuse_reply__failed[] = "fuse_readlink(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_releasedir_fuse_reply__fail[] = "fuse_releasedir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_removexattr_fuse_reply__fai[] = "fuse_removexattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_rename_fuse_reply__failed_w[] = "fuse_rename(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_rmdir_fuse_reply__failed_wi[] = "fuse_rmdir(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_setattr_clock_gettime_CLOCK[] = "fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s"; static char __pyx_k_fuse_setxattr_fuse_reply__failed[] = "fuse_setxattr(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_statfs_fuse_reply__failed_w[] = "fuse_statfs(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_unlink_fuse_reply__failed_w[] = "fuse_unlink(): fuse_reply_* failed with %s"; static char __pyx_k_fuse_write_fuse_reply_err_d_fail[] = "fuse_write(): fuse_reply_err(%d) failed with %s"; static char __pyx_k_fuse_write_fuse_reply_err_failed[] = "fuse_write(): fuse_reply_err failed with %s after exception"; static char __pyx_k_fuse_write_fuse_reply_write_fail[] = "fuse_write(): fuse_reply_write failed with %s"; static char __pyx_k_handler_raised_exception_sending[] = "handler raised exception, sending SIGTERM to self."; static char __pyx_k_home_nikratio_in_progress_pytho_2[] = "/home/nikratio/in-progress/python-llfuse/src/llfuse/fuse_api.pxi"; static PyObject *__pyx_n_s_BaseException; static PyObject *__pyx_kp_u_Calling_fuse_lowlevel_new; static PyObject *__pyx_kp_u_Calling_fuse_mount; static PyObject *__pyx_kp_u_Calling_fuse_remove_signal_handl; static PyObject *__pyx_kp_u_Calling_fuse_session_add_chan; static PyObject *__pyx_kp_u_Calling_fuse_session_destroy; static PyObject *__pyx_kp_u_Calling_fuse_session_loop; static PyObject *__pyx_kp_u_Calling_fuse_session_loop_mt; static PyObject *__pyx_kp_u_Calling_fuse_session_remove_chan; static PyObject *__pyx_kp_u_Calling_fuse_set_signal_handlers; static PyObject *__pyx_kp_u_Calling_fuse_unmount; static PyObject *__pyx_n_s_ENOATTR; static PyObject *__pyx_n_s_EntryAttributes; static PyObject *__pyx_kp_u_Exception_after_kill; static PyObject *__pyx_n_s_FUSEError; static PyObject *__pyx_kp_u_Global_lock_cannot_be_acquired_m; static PyObject *__pyx_kp_u_Initializing_llfuse; static PyObject *__pyx_kp_u_Lock_can_only_be_released_by_the; static PyObject *__pyx_kp_u_Lock_not_initialized; static PyObject *__pyx_kp_u_Lock_still_taken_after_receiving; static PyObject *__pyx_kp_u_Need_to_call_init_before_main; static PyObject *__pyx_n_s_OSError; static PyObject *__pyx_n_s_Operations; static PyObject *__pyx_kp_u_Other_thread_didn_t_take_lock; static PyObject *__pyx_kp_b_Python_LLFUSE; static PyObject *__pyx_n_s_Queue; static PyObject *__pyx_n_s_ROOT_INODE; static PyObject *__pyx_n_s_RequestContext; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_kp_u_Terminated_main_loop_because_req; static PyObject *__pyx_n_s_Thread; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_kp_u_Weird_request_received_r; static PyObject *__pyx_kp_u_You_should_not_instantiate_this; static PyObject *__pyx_kp_b__28; static PyObject *__pyx_n_s_abspath; static PyObject *__pyx_n_s_access; static PyObject *__pyx_n_s_acquire; static PyObject *__pyx_n_s_args; static PyObject *__pyx_n_s_attr_only; static PyObject *__pyx_n_u_attr_only; static PyObject *__pyx_n_s_attr_timeout; static PyObject *__pyx_n_s_block; static PyObject *__pyx_n_s_buf; static PyObject *__pyx_n_s_bufsize; static PyObject *__pyx_n_s_close; static PyObject *__pyx_n_s_cname; static PyObject *__pyx_n_s_collections; static PyObject *__pyx_n_s_count; static PyObject *__pyx_n_s_cpath; static PyObject *__pyx_n_s_create; static PyObject *__pyx_n_s_cvalue; static PyObject *__pyx_n_s_daemon; static PyObject *__pyx_n_s_debug; static PyObject *__pyx_n_s_decode; static PyObject *__pyx_n_s_destroy; static PyObject *__pyx_n_s_dirp; static PyObject *__pyx_n_s_encode; static PyObject *__pyx_n_s_ent; static PyObject *__pyx_n_s_enter; static PyObject *__pyx_n_s_entry_timeout; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_errno; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_exc_info; static PyObject *__pyx_n_s_exc_tb; static PyObject *__pyx_n_s_exc_type; static PyObject *__pyx_n_s_exc_val; static PyObject *__pyx_n_s_exception; static PyObject *__pyx_n_s_exit; static PyObject *__pyx_n_s_f_args; static PyObject *__pyx_n_s_f_bavail; static PyObject *__pyx_n_s_f_bfree; static PyObject *__pyx_n_s_f_blocks; static PyObject *__pyx_n_s_f_bsize; static PyObject *__pyx_n_s_f_favail; static PyObject *__pyx_n_s_f_ffree; static PyObject *__pyx_n_s_f_files; static PyObject *__pyx_n_s_f_frsize; static PyObject *__pyx_n_s_flush; static PyObject *__pyx_n_s_forget; static PyObject *__pyx_n_s_fse; static PyObject *__pyx_n_s_fsync; static PyObject *__pyx_n_s_fsyncdir; static PyObject *__pyx_kp_u_fuse_access_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_create_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_flush_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_getattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_getxattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_link_fuse_reply__failed_wit; static PyObject *__pyx_kp_u_fuse_listxattr_fuse_reply__faile; static PyObject *__pyx_kp_u_fuse_lookup_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_lowlevel_new_failed; static PyObject *__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_mount_failed; static PyObject *__pyx_kp_u_fuse_opendir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_options_must_be_of_type_str; static PyObject *__pyx_kp_u_fuse_read_fuse_reply__failed_wit; static PyObject *__pyx_kp_u_fuse_readdir_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_readlink_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_release_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_releasedir_fuse_reply__fail; static PyObject *__pyx_kp_u_fuse_removexattr_fuse_reply__fai; static PyObject *__pyx_kp_u_fuse_rename_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_session_loop_failed; static PyObject *__pyx_kp_u_fuse_session_loop_mt_failed; static PyObject *__pyx_kp_u_fuse_set_signal_handlers_failed; static PyObject *__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK; static PyObject *__pyx_kp_u_fuse_setattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_setxattr_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_statfs_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_symlink_fuse_reply__failed; static PyObject *__pyx_kp_u_fuse_unlink_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_err_d_fail; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_err_failed; static PyObject *__pyx_kp_u_fuse_write_fuse_reply_write_fail; static PyObject *__pyx_n_s_generation; static PyObject *__pyx_n_s_get; static PyObject *__pyx_n_s_getLogger; static PyObject *__pyx_n_s_get_ino_t_bits; static PyObject *__pyx_n_s_get_off_t_bits; static PyObject *__pyx_n_s_getattr; static PyObject *__pyx_n_s_getfilesystemencoding; static PyObject *__pyx_n_s_getxattr; static PyObject *__pyx_n_s_gid; static PyObject *__pyx_kp_u_handler_raised_exception_sending; static PyObject *__pyx_kp_s_home_nikratio_in_progress_pytho; static PyObject *__pyx_kp_s_home_nikratio_in_progress_pytho_2; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_s_ino; static PyObject *__pyx_n_s_inode; static PyObject *__pyx_n_u_inode; static PyObject *__pyx_n_s_inode_p; static PyObject *__pyx_n_u_inode_p; static PyObject *__pyx_n_s_inval_entry_req; static PyObject *__pyx_n_u_inval_entry_req; static PyObject *__pyx_n_s_inval_inode_req; static PyObject *__pyx_n_u_inval_inode_req; static PyObject *__pyx_n_s_invalidate_entry; static PyObject *__pyx_n_s_invalidate_inode; static PyObject *__pyx_n_s_join; static PyObject *__pyx_n_s_len; static PyObject *__pyx_n_s_link; static PyObject *__pyx_n_s_listdir; static PyObject *__pyx_n_s_listxattr; static PyObject *__pyx_n_u_llfuse; static PyObject *__pyx_n_s_llfuse_capi; static PyObject *__pyx_n_s_llfuse_pyapi; static PyObject *__pyx_n_s_lock; static PyObject *__pyx_n_s_lock_released; static PyObject *__pyx_n_s_log; static PyObject *__pyx_n_s_logging; static PyObject *__pyx_n_s_lookup; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_main_2; static PyObject *__pyx_n_s_maxsize; static PyObject *__pyx_n_s_mkdir; static PyObject *__pyx_n_s_mknod; static PyObject *__pyx_n_s_mountpoint; static PyObject *__pyx_kp_u_mountpoint__argument_must_be_of; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_u_name; static PyObject *__pyx_kp_u_name_argument_must_be_of_type_s; static PyObject *__pyx_n_s_name_b; static PyObject *__pyx_n_s_namedtuple; static PyObject *__pyx_n_s_names; static PyObject *__pyx_n_s_namespace; static PyObject *__pyx_kp_u_namespace_parameter_must_be_sys; static PyObject *__pyx_n_s_notify_loop; static PyObject *__pyx_n_s_notify_queue; static PyObject *__pyx_kp_b_o; static PyObject *__pyx_n_s_open; static PyObject *__pyx_n_s_opendir; static PyObject *__pyx_n_s_ops; static PyObject *__pyx_n_s_os; static PyObject *__pyx_n_s_os_path; static PyObject *__pyx_n_s_path; static PyObject *__pyx_kp_u_path_argument_must_be_of_type_s; static PyObject *__pyx_n_s_path_b; static PyObject *__pyx_n_s_pid; static PyObject *__pyx_n_s_put; static PyObject *__pyx_n_s_queue; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_read; static PyObject *__pyx_n_s_readdir; static PyObject *__pyx_n_s_readlink; static PyObject *__pyx_n_s_release; static PyObject *__pyx_n_s_releasedir; static PyObject *__pyx_n_s_removexattr; static PyObject *__pyx_n_s_rename; static PyObject *__pyx_n_s_req; static PyObject *__pyx_n_s_res; static PyObject *__pyx_n_s_ret; static PyObject *__pyx_n_s_rmdir; static PyObject *__pyx_n_s_setattr; static PyObject *__pyx_n_s_setxattr; static PyObject *__pyx_n_s_single; static PyObject *__pyx_n_s_size_guess; static PyObject *__pyx_n_s_st_atime; static PyObject *__pyx_n_s_st_atime_ns; static PyObject *__pyx_n_s_st_blksize; static PyObject *__pyx_n_s_st_blocks; static PyObject *__pyx_n_s_st_ctime; static PyObject *__pyx_n_s_st_ctime_ns; static PyObject *__pyx_n_s_st_gid; static PyObject *__pyx_n_s_st_ino; static PyObject *__pyx_n_s_st_mode; static PyObject *__pyx_n_s_st_mtime; static PyObject *__pyx_n_s_st_mtime_ns; static PyObject *__pyx_n_s_st_nlink; static PyObject *__pyx_n_s_st_rdev; static PyObject *__pyx_n_s_st_size; static PyObject *__pyx_n_s_st_uid; static PyObject *__pyx_n_s_stacktrace; static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_statfs; static PyObject *__pyx_n_s_str_t; static PyObject *__pyx_n_s_strerror; static PyObject *__pyx_n_u_surrogateescape; static PyObject *__pyx_n_s_symlink; static PyObject *__pyx_n_s_sys; static PyObject *__pyx_n_u_system; static PyObject *__pyx_n_s_t; static PyObject *__pyx_n_s_target; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_threading; static PyObject *__pyx_n_s_timeout; static PyObject *__pyx_n_s_tmp; static PyObject *__pyx_n_s_uid; static PyObject *__pyx_n_s_umask; static PyObject *__pyx_kp_u_unknown_flag_s_o; static PyObject *__pyx_n_s_unlink; static PyObject *__pyx_n_s_unmount; static PyObject *__pyx_kp_u_us_ascii; static PyObject *__pyx_n_u_user; static PyObject *__pyx_n_s_value; static PyObject *__pyx_n_s_version; static PyObject *__pyx_n_s_with_traceback; static PyObject *__pyx_n_s_write; static PyObject *__pyx_float_1e9; static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_5; static PyObject *__pyx_int_1000; static PyObject *__pyx_int_1000000000; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_tuple__4; static PyObject *__pyx_tuple__5; static PyObject *__pyx_tuple__6; static PyObject *__pyx_tuple__7; static PyObject *__pyx_tuple__8; static PyObject *__pyx_tuple__9; static PyObject *__pyx_tuple__10; static PyObject *__pyx_tuple__11; static PyObject *__pyx_tuple__12; static PyObject *__pyx_tuple__13; static PyObject *__pyx_tuple__14; static PyObject *__pyx_tuple__15; static PyObject *__pyx_tuple__16; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__18; static PyObject *__pyx_tuple__19; static PyObject *__pyx_tuple__20; static PyObject *__pyx_tuple__21; static PyObject *__pyx_tuple__22; static PyObject *__pyx_tuple__23; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__26; static PyObject *__pyx_tuple__27; static PyObject *__pyx_tuple__29; static PyObject *__pyx_tuple__30; static PyObject *__pyx_tuple__31; static PyObject *__pyx_tuple__32; static PyObject *__pyx_tuple__33; static PyObject *__pyx_tuple__34; static PyObject *__pyx_tuple__35; static PyObject *__pyx_tuple__36; static PyObject *__pyx_tuple__37; static PyObject *__pyx_tuple__38; static PyObject *__pyx_tuple__39; static PyObject *__pyx_tuple__40; static PyObject *__pyx_tuple__41; static PyObject *__pyx_tuple__42; static PyObject *__pyx_tuple__43; static PyObject *__pyx_tuple__44; static PyObject *__pyx_tuple__45; static PyObject *__pyx_tuple__46; static PyObject *__pyx_tuple__47; static PyObject *__pyx_tuple__48; static PyObject *__pyx_tuple__51; static PyObject *__pyx_tuple__52; static PyObject *__pyx_tuple__53; static PyObject *__pyx_tuple__54; static PyObject *__pyx_tuple__55; static PyObject *__pyx_tuple__56; static PyObject *__pyx_tuple__57; static PyObject *__pyx_tuple__58; static PyObject *__pyx_tuple__59; static PyObject *__pyx_tuple__60; static PyObject *__pyx_tuple__61; static PyObject *__pyx_tuple__62; static PyObject *__pyx_tuple__63; static PyObject *__pyx_tuple__64; static PyObject *__pyx_tuple__65; static PyObject *__pyx_tuple__66; static PyObject *__pyx_tuple__67; static PyObject *__pyx_tuple__68; static PyObject *__pyx_tuple__69; static PyObject *__pyx_tuple__70; static PyObject *__pyx_tuple__71; static PyObject *__pyx_tuple__72; static PyObject *__pyx_tuple__73; static PyObject *__pyx_tuple__74; static PyObject *__pyx_tuple__75; static PyObject *__pyx_tuple__76; static PyObject *__pyx_tuple__77; static PyObject *__pyx_tuple__79; static PyObject *__pyx_tuple__81; static PyObject *__pyx_tuple__83; static PyObject *__pyx_tuple__85; static PyObject *__pyx_tuple__87; static PyObject *__pyx_tuple__89; static PyObject *__pyx_tuple__91; static PyObject *__pyx_tuple__93; static PyObject *__pyx_codeobj__78; static PyObject *__pyx_codeobj__80; static PyObject *__pyx_codeobj__82; static PyObject *__pyx_codeobj__84; static PyObject *__pyx_codeobj__86; static PyObject *__pyx_codeobj__88; static PyObject *__pyx_codeobj__90; static PyObject *__pyx_codeobj__92; static PyObject *__pyx_codeobj__94; static PyObject *__pyx_codeobj__95; static PyObject *__pyx_codeobj__96; /* "src/llfuse/handlers.pxi":14 * ''' * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: # <<<<<<<<<<<<<< * try: * with lock: */ static void __pyx_f_6llfuse_4capi_fuse_init(CYTHON_UNUSED void *__pyx_v_userdata, CYTHON_UNUSED struct fuse_conn_info *__pyx_v_conn) { PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_init", 0); /* "src/llfuse/handlers.pxi":15 * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: # <<<<<<<<<<<<<< * with lock: * operations.init() */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":17 * try: * with lock: * operations.init() # <<<<<<<<<<<<<< * except BaseException as e: * handle_exc('init', e, NULL) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_init); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_13 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_14 = ((!(__pyx_t_13 != 0)) != 0); if (__pyx_t_14) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple_, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":18 * with lock: * operations.init() * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('init', e, NULL) * */ __pyx_t_15 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_15) { __Pyx_AddTraceback("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":19 * operations.init() * except BaseException as e: * handle_exc('init', e, NULL) # <<<<<<<<<<<<<< * * cdef void fuse_destroy (void *userdata) with gil: */ __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_init, __pyx_v_e, NULL); } /* "src/llfuse/handlers.pxi":18 * with lock: * operations.init() * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('init', e, NULL) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":14 * ''' * * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: # <<<<<<<<<<<<<< * try: * with lock: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_WriteUnraisable("llfuse.capi.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":21 * handle_exc('init', e, NULL) * * cdef void fuse_destroy (void *userdata) with gil: # <<<<<<<<<<<<<< * # Note: called by fuse_session_destroy(), i.e. not as part of the * # main loop but only when llfuse.close() is called. */ static void __pyx_f_6llfuse_4capi_fuse_destroy(CYTHON_UNUSED void *__pyx_v_userdata) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_destroy", 0); /* "src/llfuse/handlers.pxi":26 * # (therefore we don't obtain the global lock) * global exc_info * try: # <<<<<<<<<<<<<< * operations.destroy() * except: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":27 * global exc_info * try: * operations.destroy() # <<<<<<<<<<<<<< * except: * if not exc_info: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_destroy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":28 * try: * operations.destroy() * except: # <<<<<<<<<<<<<< * if not exc_info: * exc_info = sys.exc_info() */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_destroy", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); /* "src/llfuse/handlers.pxi":29 * operations.destroy() * except: * if not exc_info: # <<<<<<<<<<<<<< * exc_info = sys.exc_info() * else: */ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __pyx_t_8 = ((!__pyx_t_7) != 0); if (__pyx_t_8) { /* "src/llfuse/handlers.pxi":30 * except: * if not exc_info: * exc_info = sys.exc_info() # <<<<<<<<<<<<<< * else: * log.exception('Exception after kill:') */ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_11))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (__pyx_t_10) { __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_10); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else { __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} } __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L13; } /*else*/ { /* "src/llfuse/handlers.pxi":32 * exc_info = sys.exc_info() * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, */ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_exception); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __pyx_L13:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_exception_handled; } __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":21 * handle_exc('init', e, NULL) * * cdef void fuse_destroy (void *userdata) with gil: # <<<<<<<<<<<<<< * # Note: called by fuse_session_destroy(), i.e. not as part of the * # main loop but only when llfuse.close() is called. */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_WriteUnraisable("llfuse.capi.fuse_destroy", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":34 * log.exception('Exception after kill:') * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef fuse_entry_param entry */ static void __pyx_f_6llfuse_4capi_fuse_lookup(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { struct fuse_entry_param __pyx_v_entry; int __pyx_v_ret; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_lookup", 0); /* "src/llfuse/handlers.pxi":39 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":41 * try: * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_lookup); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__3, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":42 * with lock: * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_14 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 42; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":43 * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":44 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":45 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('lookup', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":44 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":46 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('lookup', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":47 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('lookup', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_lookup, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":46 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('lookup', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":49 * ret = handle_exc('lookup', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":50 * * if ret != 0: * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_lookup_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":34 * log.exception('Exception after kill:') * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef fuse_entry_param entry */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":53 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * ulong_t nlookup) with gil: * try: */ static void __pyx_f_6llfuse_4capi_fuse_forget(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, unsigned long __pyx_v_nlookup) { PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_forget", 0); /* "src/llfuse/handlers.pxi":55 * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, * ulong_t nlookup) with gil: * try: # <<<<<<<<<<<<<< * with lock: * operations.forget([(ino, nlookup)]) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":57 * try: * with lock: * operations.forget([(ino, nlookup)]) # <<<<<<<<<<<<<< * except BaseException as e: * handle_exc('forget', e, NULL) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_forget); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_unsigned_long(__pyx_v_nlookup); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_12) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__4, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":58 * with lock: * operations.forget([(ino, nlookup)]) * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('forget', e, NULL) * fuse_reply_none(req) */ __pyx_t_16 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":59 * operations.forget([(ino, nlookup)]) * except BaseException as e: * handle_exc('forget', e, NULL) # <<<<<<<<<<<<<< * fuse_reply_none(req) * */ __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_forget, __pyx_v_e, NULL); } /* "src/llfuse/handlers.pxi":58 * with lock: * operations.forget([(ino, nlookup)]) * except BaseException as e: # <<<<<<<<<<<<<< * handle_exc('forget', e, NULL) * fuse_reply_none(req) */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":60 * except BaseException as e: * handle_exc('forget', e, NULL) * fuse_reply_none(req) # <<<<<<<<<<<<<< * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, */ fuse_reply_none(__pyx_v_req); /* "src/llfuse/handlers.pxi":53 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * ulong_t nlookup) with gil: * try: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_WriteUnraisable("llfuse.capi.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":62 * fuse_reply_none(req) * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef c_stat stat */ static void __pyx_f_6llfuse_4capi_fuse_getattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, CYTHON_UNUSED struct fuse_file_info *__pyx_v_fi) { struct stat __pyx_v_stat; int __pyx_v_ret; int __pyx_v_timeout; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_getattr", 0); /* "src/llfuse/handlers.pxi":68 * cdef int timeout * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.getattr(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":70 * try: * with lock: * attr = operations.getattr(ino) # <<<<<<<<<<<<<< * * fill_c_stat(attr, &stat) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 70; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__5, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":72 * attr = operations.getattr(ino) * * fill_c_stat(attr, &stat) # <<<<<<<<<<<<<< * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_12 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 72; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":73 * * fill_c_stat(attr, &stat) * timeout = attr.attr_timeout # <<<<<<<<<<<<<< * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 73; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_timeout = __pyx_t_16; /* "src/llfuse/handlers.pxi":74 * fill_c_stat(attr, &stat) * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_attr(__pyx_v_req, (&__pyx_v_stat), __pyx_v_timeout); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":75 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":76 * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('getattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":75 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":77 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getattr', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":78 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('getattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_getattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":77 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":80 * ret = handle_exc('getattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":81 * * if ret != 0: * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_getattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":62 * fuse_reply_none(req) * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef c_stat stat */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":83 * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_setattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct stat *__pyx_v_stat, int __pyx_v_to_set, CYTHON_UNUSED struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; struct stat __pyx_v_stat_n; int __pyx_v_timeout; struct timespec __pyx_v_now; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_setattr", 0); /* "src/llfuse/handlers.pxi":90 * cdef timespec now * * try: # <<<<<<<<<<<<<< * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":91 * * try: * attr = EntryAttributes() # <<<<<<<<<<<<<< * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_EntryAttributes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_6) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 91; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":92 * try: * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): # <<<<<<<<<<<<<< * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: */ __pyx_t_7 = ((__pyx_v_to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW)) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":93 * attr = EntryAttributes() * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', */ __pyx_v_ret = clock_gettime(CLOCK_REALTIME, (&__pyx_v_now)); /* "src/llfuse/handlers.pxi":94 * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) */ __pyx_t_7 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":95 * ret = clock_gettime(CLOCK_REALTIME, &now) * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', # <<<<<<<<<<<<<< * strerror(errno.errno)) * */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/llfuse/handlers.pxi":96 * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) # <<<<<<<<<<<<<< * * # Type casting required on 64bit, where double */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_10) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = NULL; PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_11 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_12, __pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_12, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L12; } __pyx_L12:; goto __pyx_L11; } __pyx_L11:; /* "src/llfuse/handlers.pxi":100 * # Type casting required on 64bit, where double * # is smaller than long int. * if to_set & FUSE_SET_ATTR_ATIME: # <<<<<<<<<<<<<< * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_ATIME) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":101 * # is smaller than long int. * if to_set & FUSE_SET_ATTR_ATIME: * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 # <<<<<<<<<<<<<< * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: */ __pyx_t_4 = PyFloat_FromDouble((((double)__pyx_v_stat->st_atime) + (((double)GET_ATIME_NS(__pyx_v_stat)) * 1e-9))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":102 * if to_set & FUSE_SET_ATTR_ATIME: * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec */ __pyx_t_4 = __Pyx_PyInt_From_long(((__pyx_v_stat->st_atime * 1000000000) + GET_ATIME_NS(__pyx_v_stat))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 102; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 102; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L13; } /* "src/llfuse/handlers.pxi":103 * attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: # <<<<<<<<<<<<<< * attr.st_atime = now.tv_sec * attr.st_atime_ns = now.tv_nsec */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_ATIME_NOW) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":104 * attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec # <<<<<<<<<<<<<< * attr.st_atime_ns = now.tv_nsec * else: */ __pyx_t_4 = __Pyx_PyInt_From_time_t(__pyx_v_now.tv_sec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":105 * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * attr.st_atime = now.tv_sec * attr.st_atime_ns = now.tv_nsec # <<<<<<<<<<<<<< * else: * attr.st_atime = attr.st_atime_ns = None */ __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_now.tv_nsec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L13; } /*else*/ { /* "src/llfuse/handlers.pxi":107 * attr.st_atime_ns = now.tv_nsec * else: * attr.st_atime = attr.st_atime_ns = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_MTIME: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L13:; /* "src/llfuse/handlers.pxi":109 * attr.st_atime = attr.st_atime_ns = None * * if to_set & FUSE_SET_ATTR_MTIME: # <<<<<<<<<<<<<< * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MTIME) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":110 * * if to_set & FUSE_SET_ATTR_MTIME: * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 # <<<<<<<<<<<<<< * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: */ __pyx_t_4 = PyFloat_FromDouble((((double)__pyx_v_stat->st_mtime) + (((double)GET_MTIME_NS(__pyx_v_stat)) * 1e-9))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 110; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 110; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":111 * if to_set & FUSE_SET_ATTR_MTIME: * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec */ __pyx_t_4 = __Pyx_PyInt_From_long(((__pyx_v_stat->st_mtime * 1000000000) + GET_MTIME_NS(__pyx_v_stat))); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 111; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 111; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L14; } /* "src/llfuse/handlers.pxi":112 * attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: # <<<<<<<<<<<<<< * attr.st_mtime = now.tv_sec * attr.st_mtime_ns = now.tv_nsec */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MTIME_NOW) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":113 * attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec # <<<<<<<<<<<<<< * attr.st_mtime_ns = now.tv_nsec * else: */ __pyx_t_4 = __Pyx_PyInt_From_time_t(__pyx_v_now.tv_sec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":114 * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * attr.st_mtime = now.tv_sec * attr.st_mtime_ns = now.tv_nsec # <<<<<<<<<<<<<< * else: * attr.st_mtime = attr.st_mtime_ns = None */ __pyx_t_4 = __Pyx_PyInt_From_long(__pyx_v_now.tv_nsec); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 114; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 114; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L14; } /*else*/ { /* "src/llfuse/handlers.pxi":116 * attr.st_mtime_ns = now.tv_nsec * else: * attr.st_mtime = attr.st_mtime_ns = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_MODE: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 116; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 116; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L14:; /* "src/llfuse/handlers.pxi":118 * attr.st_mtime = attr.st_mtime_ns = None * * if to_set & FUSE_SET_ATTR_MODE: # <<<<<<<<<<<<<< * attr.st_mode = stat.st_mode * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_MODE) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":119 * * if to_set & FUSE_SET_ATTR_MODE: * attr.st_mode = stat.st_mode # <<<<<<<<<<<<<< * else: * attr.st_mode = None */ __pyx_t_4 = __Pyx_PyInt_From_mode_t(__pyx_v_stat->st_mode); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L15; } /*else*/ { /* "src/llfuse/handlers.pxi":121 * attr.st_mode = stat.st_mode * else: * attr.st_mode = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_UID: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 121; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L15:; /* "src/llfuse/handlers.pxi":123 * attr.st_mode = None * * if to_set & FUSE_SET_ATTR_UID: # <<<<<<<<<<<<<< * attr.st_uid = stat.st_uid * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_UID) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":124 * * if to_set & FUSE_SET_ATTR_UID: * attr.st_uid = stat.st_uid # <<<<<<<<<<<<<< * else: * attr.st_uid = None */ __pyx_t_4 = __Pyx_PyInt_From_uid_t(__pyx_v_stat->st_uid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 124; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 124; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L16; } /*else*/ { /* "src/llfuse/handlers.pxi":126 * attr.st_uid = stat.st_uid * else: * attr.st_uid = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_GID: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 126; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L16:; /* "src/llfuse/handlers.pxi":128 * attr.st_uid = None * * if to_set & FUSE_SET_ATTR_GID: # <<<<<<<<<<<<<< * attr.st_gid = stat.st_gid * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_GID) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":129 * * if to_set & FUSE_SET_ATTR_GID: * attr.st_gid = stat.st_gid # <<<<<<<<<<<<<< * else: * attr.st_gid = None */ __pyx_t_4 = __Pyx_PyInt_From_gid_t(__pyx_v_stat->st_gid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 129; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 129; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L17; } /*else*/ { /* "src/llfuse/handlers.pxi":131 * attr.st_gid = stat.st_gid * else: * attr.st_gid = None # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_SIZE: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 131; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L17:; /* "src/llfuse/handlers.pxi":133 * attr.st_gid = None * * if to_set & FUSE_SET_ATTR_SIZE: # <<<<<<<<<<<<<< * attr.st_size = stat.st_size * else: */ __pyx_t_7 = ((__pyx_v_to_set & FUSE_SET_ATTR_SIZE) != 0); if (__pyx_t_7) { /* "src/llfuse/handlers.pxi":134 * * if to_set & FUSE_SET_ATTR_SIZE: * attr.st_size = stat.st_size # <<<<<<<<<<<<<< * else: * attr.st_size = None */ __pyx_t_4 = __Pyx_PyInt_From_off_t(__pyx_v_stat->st_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 134; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_size, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 134; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L18; } /*else*/ { /* "src/llfuse/handlers.pxi":136 * attr.st_size = stat.st_size * else: * attr.st_size = None # <<<<<<<<<<<<<< * * with lock: */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_attr, __pyx_n_s_st_size, Py_None) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 136; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_L18:; /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_13 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_11 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_11))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (__pyx_t_5) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L19_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); /*try:*/ { /* "src/llfuse/handlers.pxi":139 * * with lock: * attr = operations.setattr(ino, attr) # <<<<<<<<<<<<<< * * fill_c_stat(attr, &stat_n) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_setattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_11 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_12, __pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); __Pyx_INCREF(__pyx_v_attr); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_12, __pyx_v_attr); __Pyx_GIVEREF(__pyx_v_attr); __pyx_t_11 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 139; __pyx_clineno = __LINE__; goto __pyx_L25_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF_SET(__pyx_v_attr, __pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L32_try_end; __pyx_L25_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); __pyx_t_11 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_11, NULL); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_7 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} __pyx_t_18 = ((!(__pyx_t_7 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_8); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_8 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L27_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L26_exception_handled; } __pyx_L27_except_error:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); goto __pyx_L3_error; __pyx_L26_exception_handled:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_L32_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_13) { __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_tuple__6, NULL); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; } goto __pyx_L24; } __pyx_L24:; } goto __pyx_L36; __pyx_L19_error:; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L3_error; __pyx_L36:; } /* "src/llfuse/handlers.pxi":141 * attr = operations.setattr(ino, attr) * * fill_c_stat(attr, &stat_n) # <<<<<<<<<<<<<< * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) */ __pyx_t_8 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat_n)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 141; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/llfuse/handlers.pxi":142 * * fill_c_stat(attr, &stat_n) * timeout = attr.attr_timeout # <<<<<<<<<<<<<< * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 142; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_timeout = __pyx_t_19; /* "src/llfuse/handlers.pxi":143 * fill_c_stat(attr, &stat_n) * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_attr(__pyx_v_req, (&__pyx_v_stat_n), __pyx_v_timeout); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/llfuse/handlers.pxi":144 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":145 * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('setattr', e, req) */ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 145; __pyx_clineno = __LINE__; goto __pyx_L42_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_11); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 145; __pyx_clineno = __LINE__; goto __pyx_L42_error;} __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":144 * timeout = attr.attr_timeout * ret = fuse_reply_attr(req, &stat_n, timeout) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L43; } /*exception exit:*/{ __pyx_L42_error:; __pyx_t_13 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_17 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_17, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_16, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_16, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_17, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_16, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_17 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L43:; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":146 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setattr', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":147 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('setattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_setattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":146 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L54; } __pyx_L54:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":149 * ret = handle_exc('setattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":150 * * if ret != 0: * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_11); __pyx_t_5 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_11))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } if (!__pyx_t_9) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __pyx_t_11 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_11)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_11); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_10 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_11) { PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_11); __Pyx_GIVEREF(__pyx_t_11); __pyx_t_11 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_12, __pyx_kp_u_fuse_setattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L55; } __pyx_L55:; /* "src/llfuse/handlers.pxi":83 * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_WriteUnraisable("llfuse.capi.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":152 * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ static void __pyx_f_6llfuse_4capi_fuse_readlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino) { int __pyx_v_ret; char *__pyx_v_name; PyObject *__pyx_v_target = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; char *__pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; Py_ssize_t __pyx_t_23; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_readlink", 0); /* "src/llfuse/handlers.pxi":155 * cdef int ret * cdef char* name * try: # <<<<<<<<<<<<<< * with lock: * target = operations.readlink(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":157 * try: * with lock: * target = operations.readlink(ino) # <<<<<<<<<<<<<< * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_readlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_target = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":158 * with lock: * target = operations.readlink(ino) * name = PyBytes_AsString(target) # <<<<<<<<<<<<<< * ret = fuse_reply_readlink(req, name) * except FUSEError as e: */ if (unlikely(!__pyx_v_target)) { __Pyx_RaiseUnboundLocalError("target"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 158; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = PyBytes_AsString(__pyx_v_target); if (unlikely(__pyx_t_16 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 158; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_name = __pyx_t_16; /* "src/llfuse/handlers.pxi":159 * target = operations.readlink(ino) * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_readlink(__pyx_v_req, __pyx_v_name); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":160 * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 160; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 160; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":161 * ret = fuse_reply_readlink(req, name) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('readlink', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 161; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":160 * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(req, name) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":162 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readlink', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 162; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":163 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('readlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_readlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":162 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":165 * ret = handle_exc('readlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":166 * * if ret != 0: * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_23 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_23 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_23); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_23, __pyx_kp_u_fuse_readlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_23, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":152 * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_target); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":168 * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_mknod(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode, dev_t __pyx_v_rdev) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_mknod", 0); /* "src/llfuse/handlers.pxi":173 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":174 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 174; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":176 * ctx = get_request_context(req) * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, # <<<<<<<<<<<<<< * rdev, ctx) * fill_entry_param(attr, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_mknod); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); /* "src/llfuse/handlers.pxi":177 * with lock: * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_13 = __Pyx_PyInt_From_dev_t(__pyx_v_rdev); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 177; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } __pyx_t_16 = PyTuple_New(5+__pyx_t_15); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_16); if (__pyx_t_14) { PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = NULL; } PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_16, 4+__pyx_t_15, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_16, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 176; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_16); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_18 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_19 = ((!(__pyx_t_18 != 0)) != 0); if (__pyx_t_19) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_16); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":178 * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":179 * rdev, ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":180 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_16 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 180; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_16, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 180; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":181 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('mknod', e, req) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_13); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); } /* "src/llfuse/handlers.pxi":180 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_17, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_20 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_17, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":182 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mknod', e, req) * */ __pyx_t_21 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 182; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":183 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('mknod', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_mknod, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":182 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mknod', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":185 * ret = handle_exc('mknod', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/llfuse/handlers.pxi":186 * * if ret != 0: * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_13))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } if (!__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_15 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_15, __pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_15, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 186; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":168 * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_16); __Pyx_WriteUnraisable("llfuse.capi.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":188 * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_mkdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_mkdir", 0); /* "src/llfuse/handlers.pxi":193 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * # Force the entry type to directory. We need to explicitly cast, * # because on BSD the S_* are not of type mode_t. */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":196 * # Force the entry type to directory. We need to explicitly cast, * # because on BSD the S_* are not of type mode_t. * mode = ((mode & ~S_IFMT) | S_IFDIR) # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ __pyx_v_mode = ((mode_t)((__pyx_v_mode & (~S_IFMT)) | S_IFDIR)); /* "src/llfuse/handlers.pxi":197 * # because on BSD the S_* are not of type mode_t. * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 197; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":199 * ctx = get_request_context(req) * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_mkdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 199; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__9, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":200 * with lock: * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 200; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":201 * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":202 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 202; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 202; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":203 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('mkdir', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 203; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":202 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":204 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mkdir', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 204; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":205 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('mkdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_mkdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":204 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('mkdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":207 * ret = handle_exc('mkdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":208 * * if ret != 0: * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 208; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":188 * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":210 * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_unlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_unlink", 0); /* "src/llfuse/handlers.pxi":213 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.unlink(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":215 * try: * with lock: * operations.unlink(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_unlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 215; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__10, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":216 * with lock: * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":217 * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":218 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('unlink', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":217 * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":219 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('unlink', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":220 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('unlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_unlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":219 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('unlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":222 * ret = handle_exc('unlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":223 * * if ret != 0: * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_unlink_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":210 * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":225 * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_rmdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_rmdir", 0); /* "src/llfuse/handlers.pxi":228 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":230 * try: * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_rmdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 230; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__11, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":231 * with lock: * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":232 * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 232; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 232; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":233 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('rmdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":232 * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":234 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rmdir', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":235 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('rmdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_rmdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":234 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rmdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":237 * ret = handle_exc('rmdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":238 * * if ret != 0: * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":225 * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":240 * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_symlink(fuse_req_t __pyx_v_req, const char *__pyx_v_link, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_symlink", 0); /* "src/llfuse/handlers.pxi":245 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":246 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 246; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":248 * ctx = get_request_context(req) * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), # <<<<<<<<<<<<<< * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_symlink); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); /* "src/llfuse/handlers.pxi":249 * with lock: * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_12 = PyBytes_FromString(__pyx_v_link); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 249; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(4+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 248; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":250 * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":251 * PyBytes_FromString(link), ctx) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":252 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 252; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":253 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('symlink', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":252 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":254 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('symlink', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 254; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":255 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('symlink', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_symlink, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":254 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('symlink', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":257 * ret = handle_exc('symlink', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":258 * * if ret != 0: * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_symlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 258; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":240 * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":260 * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_rename(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; Py_ssize_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_rename", 0); /* "src/llfuse/handlers.pxi":264 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.rename(parent, PyBytes_FromString(name), */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":266 * try: * with lock: * operations.rename(parent, PyBytes_FromString(name), # <<<<<<<<<<<<<< * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_rename); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); /* "src/llfuse/handlers.pxi":267 * with lock: * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_12 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_newparent); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_14 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_14)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_15 = 1; } } __pyx_t_16 = PyTuple_New(4+__pyx_t_15); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_16); if (__pyx_t_14) { PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = NULL; } PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_15, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_15, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_16, 2+__pyx_t_15, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_16, 3+__pyx_t_15, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_16, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_16); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_17); __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_17); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; if (__pyx_t_18 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_19 = ((!(__pyx_t_18 != 0)) != 0); if (__pyx_t_19) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_16); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_16 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__13, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":268 * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; /* "src/llfuse/handlers.pxi":269 * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_16 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_16, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":270 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('rename', e, req) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_13); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 270; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); } /* "src/llfuse/handlers.pxi":269 * newparent, PyBytes_FromString(newname)) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_17, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_20 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_17, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_17 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":271 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rename', e, req) * */ __pyx_t_21 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_16); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":272 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('rename', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_rename, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":271 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('rename', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":274 * ret = handle_exc('rename', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/llfuse/handlers.pxi":275 * * if ret != 0: * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_13))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_13); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_13, function); } } if (!__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = NULL; __pyx_t_15 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_15 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_15, __pyx_kp_u_fuse_rename_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_15, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":260 * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_16); __Pyx_WriteUnraisable("llfuse.capi.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":277 * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_link(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_link", 0); /* "src/llfuse/handlers.pxi":282 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":284 * try: * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) # <<<<<<<<<<<<<< * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_link); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_newparent); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 284; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_attr = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__14, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":285 * with lock: * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_15 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":286 * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_entry(__pyx_v_req, (&__pyx_v_entry)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":287 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":288 * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('link', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":287 * fill_entry_param(attr, &entry) * ret = fuse_reply_entry(req, &entry) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":289 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('link', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":290 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('link', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_link, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":289 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('link', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":292 * ret = handle_exc('link', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":293 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":277 * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":296 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_open(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; uint64_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_open", 0); /* "src/llfuse/handlers.pxi":299 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * fi.fh = operations.open(ino, fi.flags) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":301 * try: * with lock: * fi.fh = operations.open(ino, fi.flags) # <<<<<<<<<<<<<< * * # Cached file data does not need to be invalidated. */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_open); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_fi->flags); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyInt_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_15 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_fi->fh = __pyx_t_15; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__15, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":305 * # Cached file data does not need to be invalidated. * # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ * fi.keep_cache = 1 # <<<<<<<<<<<<<< * * ret = fuse_reply_open(req, fi) */ __pyx_v_fi->keep_cache = 1; /* "src/llfuse/handlers.pxi":307 * fi.keep_cache = 1 * * ret = fuse_reply_open(req, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_open(__pyx_v_req, __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":308 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 308; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":309 * ret = fuse_reply_open(req, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('open', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":308 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":310 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('open', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 310; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":311 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('open', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_open, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":310 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('open', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":313 * ret = handle_exc('open', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":314 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_23, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_23, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_23 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_23); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_23, 0+__pyx_t_13, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_23, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_23, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 314; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":296 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_23); __Pyx_WriteUnraisable("llfuse.capi.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":316 * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_read(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; int __pyx_t_20; char const *__pyx_t_21; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_read", 0); /* "src/llfuse/handlers.pxi":322 * cdef char* cbuf * * try: # <<<<<<<<<<<<<< * with lock: * buf = operations.read(fi.fh, off, size) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":324 * try: * with lock: * buf = operations.read(fi.fh, off, size) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_read); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(3+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 324; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_15); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_15); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_15 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__16, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":325 * with lock: * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_19 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_19 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 325; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":326 * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/llfuse/handlers.pxi":327 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 327; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":328 * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('read', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 328; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_19); } /* "src/llfuse/handlers.pxi":327 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * ret = fuse_reply_buf(req, cbuf, len_) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_22); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_22); __pyx_t_19 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_21 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_22); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_22 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_21; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":329 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('read', e, req) * */ __pyx_t_20 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":330 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('read', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_read, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":329 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('read', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":332 * ret = handle_exc('read', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":333 * * if ret != 0: * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_read_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 333; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":316 * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":335 * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_write(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, const char *__pyx_v_buf, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; size_t __pyx_v_len_; PyObject *__pyx_v_pbuf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; size_t __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; int __pyx_t_18; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; int __pyx_t_24; char const *__pyx_t_25; PyObject *__pyx_t_26 = NULL; char const *__pyx_t_27; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_write", 0); /* "src/llfuse/handlers.pxi":341 * * # GCC thinks this may end up uninitialized * len_ = 0 # <<<<<<<<<<<<<< * * try: */ __pyx_v_len_ = 0; /* "src/llfuse/handlers.pxi":343 * len_ = 0 * * try: # <<<<<<<<<<<<<< * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":344 * * try: * pbuf = PyBytes_FromStringAndSize(buf, size) # <<<<<<<<<<<<<< * with lock: * len_ = operations.write(fi.fh, off, pbuf) */ __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_pbuf = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":346 * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: * len_ = operations.write(fi.fh, off, pbuf) # <<<<<<<<<<<<<< * ret = fuse_reply_write(req, len_) * if ret != 0: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_write); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_pbuf); PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_v_pbuf); __Pyx_GIVEREF(__pyx_v_pbuf); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_15 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_15 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 346; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_len_ = __pyx_t_15; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_18 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_18) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__17, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":347 * with lock: * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) */ __pyx_v_ret = fuse_reply_write(__pyx_v_req, __pyx_v_len_); /* "src/llfuse/handlers.pxi":348 * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":349 * ret = fuse_reply_write(req, len_) * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_19 = PyTuple_New(1+1); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_19); PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_19, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_19, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_19 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_19); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_write_fail); PyTuple_SET_ITEM(__pyx_t_19, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_write_fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_write_fail); PyTuple_SET_ITEM(__pyx_t_19, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_19, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L29; } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":350 * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * if ret != 0: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_20 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_4, &__pyx_t_19) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_19); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":351 * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 351; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_20); /* "src/llfuse/handlers.pxi":352 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":353 * ret = fuse_reply_err(req, e.errno) * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('write', e, req) */ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_21 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_21); __pyx_t_22 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_22 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_22)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_22); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_22) { __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_21); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_GOTREF(__pyx_t_8); } else { __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_22); __Pyx_GIVEREF(__pyx_t_22); __pyx_t_22 = NULL; PyTuple_SET_ITEM(__pyx_t_23, 0+1, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = 0; __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_23, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_23 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_23)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_23); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_13 = 1; } } __pyx_t_21 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_23) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_23); __Pyx_GIVEREF(__pyx_t_23); __pyx_t_23 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_err_d_fail); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_err_d_fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_err_d_fail); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_21, 2+__pyx_t_13, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L37; } __pyx_L37:; } /* "src/llfuse/handlers.pxi":350 * if ret != 0: * log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * if ret != 0: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_26 = 0; __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_16, &__pyx_t_26); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_26); __pyx_t_20 = __pyx_lineno; __pyx_t_24 = __pyx_clineno; __pyx_t_25 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_26); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_16, __pyx_t_26); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_16 = 0; __pyx_t_26 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_24; __pyx_filename = __pyx_t_25; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":354 * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('write', e, req) * */ __pyx_t_24 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_24) { __Pyx_AddTraceback("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_19, &__pyx_t_4, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 354; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_19); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":355 * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: * ret = handle_exc('write', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_write, __pyx_v_e, __pyx_v_req); /* "src/llfuse/handlers.pxi":357 * ret = handle_exc('write', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/llfuse/handlers.pxi":358 * * if ret != 0: * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_error); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_21); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_23 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_23 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_23)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_23); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_23) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_23); __Pyx_GIVEREF(__pyx_t_23); __pyx_t_23 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_22, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_21))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_21); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_21); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_21, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply_err_failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_write_fuse_reply_err_failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply_err_failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_21, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 358; __pyx_clineno = __LINE__; goto __pyx_L47_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L49; } __pyx_L49:; } /* "src/llfuse/handlers.pxi":354 * if ret != 0: * log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('write', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } /*exception exit:*/{ __pyx_L47_error:; __pyx_t_26 = 0; __pyx_t_16 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_5); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_26, &__pyx_t_16, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_26, &__pyx_t_16, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_26); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_5); __pyx_t_24 = __pyx_lineno; __pyx_t_20 = __pyx_clineno; __pyx_t_27 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_5); } __Pyx_XGIVEREF(__pyx_t_26); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ErrRestore(__pyx_t_26, __pyx_t_16, __pyx_t_9); __pyx_t_26 = 0; __pyx_t_16 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_5 = 0; __pyx_lineno = __pyx_t_24; __pyx_clineno = __pyx_t_20; __pyx_filename = __pyx_t_27; goto __pyx_L5_except_error; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":335 * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_XDECREF(__pyx_t_23); __Pyx_WriteUnraisable("llfuse.capi.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_pbuf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":360 * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_flush(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_flush", 0); /* "src/llfuse/handlers.pxi":363 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.flush(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":365 * try: * with lock: * operations.flush(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_flush); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__18, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":366 * with lock: * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":367 * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 367; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":368 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('flush', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":367 * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":369 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('flush', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 369; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":370 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('flush', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_flush, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":369 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('flush', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":372 * ret = handle_exc('flush', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":373 * * if ret != 0: * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_flush_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 373; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":360 * log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":375 * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_release(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_release", 0); /* "src/llfuse/handlers.pxi":378 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.release(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":380 * try: * with lock: * operations.release(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_release); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__19, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":381 * with lock: * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":382 * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 382; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 382; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":383 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('release', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":382 * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":384 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('release', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 384; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":385 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('release', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_release, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":384 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('release', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":387 * ret = handle_exc('release', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":388 * * if ret != 0: * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_release_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_release_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_release_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":375 * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":390 * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_fsync(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_fsync", 0); /* "src/llfuse/handlers.pxi":394 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.fsync(fi.fh, datasync != 0) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":396 * try: * with lock: * operations.fsync(fi.fh, datasync != 0) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_fsync); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyBool_FromLong((__pyx_v_datasync != 0)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 396; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__20, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":397 * with lock: * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":398 * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 398; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":399 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('fsync', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 399; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 399; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":398 * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":400 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsync', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 400; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":401 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('fsync', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_fsync, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":400 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsync', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":403 * ret = handle_exc('fsync', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":404 * * if ret != 0: * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 404; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":390 * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":406 * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_opendir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; uint64_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; Py_ssize_t __pyx_t_23; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_opendir", 0); /* "src/llfuse/handlers.pxi":409 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * fi.fh = operations.opendir(ino) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":411 * try: * with lock: * fi.fh = operations.opendir(ino) # <<<<<<<<<<<<<< * * ret = fuse_reply_open(req, fi) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_opendir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyInt_As_uint64_t(__pyx_t_4); if (unlikely((__pyx_t_13 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 411; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_fi->fh = __pyx_t_13; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__21, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":413 * fi.fh = operations.opendir(ino) * * ret = fuse_reply_open(req, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_open(__pyx_v_req, __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":414 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 414; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":415 * ret = fuse_reply_open(req, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('opendir', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":414 * * ret = fuse_reply_open(req, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":416 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('opendir', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":417 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('opendir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_opendir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":416 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('opendir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":419 * ret = handle_exc('opendir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":420 * * if ret != 0: * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_23 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_23 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_23); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_23, __pyx_kp_u_fuse_opendir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_23, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 420; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":406 * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":422 * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_readdir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; char *__pyx_v_cname; char *__pyx_v_buf; size_t __pyx_v_len_; size_t __pyx_v_acc_size; struct stat __pyx_v_stat; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_next_ = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *(*__pyx_t_15)(PyObject *); PyObject *(*__pyx_t_16)(PyObject *); int __pyx_t_17; char *__pyx_t_18; off_t __pyx_t_19; PyObject *__pyx_t_20 = NULL; int __pyx_t_21; int __pyx_t_22; int __pyx_t_23; char const *__pyx_t_24; PyObject *__pyx_t_25 = NULL; char const *__pyx_t_26; PyObject *__pyx_t_27 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_readdir", 0); /* "src/llfuse/handlers.pxi":431 * * # GCC thinks this may end up uninitialized * ret = 0 # <<<<<<<<<<<<<< * * try: */ __pyx_v_ret = 0; /* "src/llfuse/handlers.pxi":433 * ret = 0 * * try: # <<<<<<<<<<<<<< * acc_size = 0 * buf = NULL */ /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":434 * * try: * acc_size = 0 # <<<<<<<<<<<<<< * buf = NULL * with lock: */ __pyx_v_acc_size = 0; /* "src/llfuse/handlers.pxi":435 * try: * acc_size = 0 * buf = NULL # <<<<<<<<<<<<<< * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): */ __pyx_v_buf = NULL; /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L14_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":437 * buf = NULL * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): # <<<<<<<<<<<<<< * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_readdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_off_t(__pyx_v_off); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) { __pyx_t_6 = __pyx_t_4; __Pyx_INCREF(__pyx_t_6); __pyx_t_13 = 0; __pyx_t_15 = NULL; } else { __pyx_t_13 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; for (;;) { if (likely(!__pyx_t_15)) { if (likely(PyList_CheckExact(__pyx_t_6))) { if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_6)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_6, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #endif } else { if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_6)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_13); __Pyx_INCREF(__pyx_t_4); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #else __pyx_t_4 = PySequence_ITEM(__pyx_t_6, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} #endif } } else { __pyx_t_4 = __pyx_t_15(__pyx_t_6); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } break; } __Pyx_GOTREF(__pyx_t_4); } if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { PyObject* sequence = __pyx_t_4; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 3)) { if (size > 3) __Pyx_RaiseTooManyValuesError(3); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_14 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); __pyx_t_7 = PyTuple_GET_ITEM(sequence, 2); } else { __pyx_t_14 = PyList_GET_ITEM(sequence, 0); __pyx_t_8 = PyList_GET_ITEM(sequence, 1); __pyx_t_7 = PyList_GET_ITEM(sequence, 2); } __Pyx_INCREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(__pyx_t_7); #else __pyx_t_14 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_7); #endif __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { Py_ssize_t index = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_16 = Py_TYPE(__pyx_t_12)->tp_iternext; index = 0; __pyx_t_14 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_14)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_14); index = 1; __pyx_t_8 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_8)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_8); index = 2; __pyx_t_7 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_7)) goto __pyx_L30_unpacking_failed; __Pyx_GOTREF(__pyx_t_7); if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_12), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_t_16 = NULL; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L31_unpacking_done; __pyx_L30_unpacking_failed:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_16 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_L31_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF_SET(__pyx_v_attr, __pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF_SET(__pyx_v_next_, __pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":438 * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: # <<<<<<<<<<<<<< * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) */ __pyx_t_17 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":439 * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) # <<<<<<<<<<<<<< * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) */ __pyx_v_buf = ((char *)malloc((__pyx_v_size * (sizeof(char))))); goto __pyx_L32; } __pyx_L32:; /* "src/llfuse/handlers.pxi":440 * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) # <<<<<<<<<<<<<< * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, */ __pyx_t_18 = PyBytes_AsString(__pyx_v_name); if (unlikely(__pyx_t_18 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 440; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __pyx_v_cname = __pyx_t_18; /* "src/llfuse/handlers.pxi":441 * buf = stdlib.malloc(size * sizeof(char)) * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) # <<<<<<<<<<<<<< * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_stat)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 441; __pyx_clineno = __LINE__; goto __pyx_L20_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":443 * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) # <<<<<<<<<<<<<< * if len_ > (size - acc_size): * break */ __pyx_t_19 = __Pyx_PyInt_As_off_t(__pyx_v_next_); if (unlikely((__pyx_t_19 == (off_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 443; __pyx_clineno = __LINE__; goto __pyx_L20_error;} /* "src/llfuse/handlers.pxi":442 * cname = PyBytes_AsString(name) * fill_c_stat(attr, &stat) * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, # <<<<<<<<<<<<<< * cname, &stat, next_) * if len_ > (size - acc_size): */ __pyx_v_len_ = fuse_add_direntry(__pyx_v_req, (__pyx_v_buf + __pyx_v_acc_size), (__pyx_v_size - __pyx_v_acc_size), __pyx_v_cname, (&__pyx_v_stat), __pyx_t_19); /* "src/llfuse/handlers.pxi":444 * len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, * cname, &stat, next_) * if len_ > (size - acc_size): # <<<<<<<<<<<<<< * break * acc_size += len_ */ __pyx_t_17 = ((__pyx_v_len_ > (__pyx_v_size - __pyx_v_acc_size)) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":445 * cname, &stat, next_) * if len_ > (size - acc_size): * break # <<<<<<<<<<<<<< * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) */ goto __pyx_L29_break; } /* "src/llfuse/handlers.pxi":446 * if len_ > (size - acc_size): * break * acc_size += len_ # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: */ __pyx_v_acc_size = (__pyx_v_acc_size + __pyx_v_len_); /* "src/llfuse/handlers.pxi":437 * buf = NULL * with lock: * for (name, attr, next_) in operations.readdir(fi.fh, off): # <<<<<<<<<<<<<< * if buf == NULL: * buf = stdlib.malloc(size * sizeof(char)) */ } __pyx_L29_break:; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L27_try_end; __pyx_L20_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_4, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_6, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __Pyx_GOTREF(__pyx_t_20); __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_t_20); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; if (__pyx_t_17 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} __pyx_t_21 = ((!(__pyx_t_17 != 0)) != 0); if (__pyx_t_21) { __Pyx_GIVEREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_6, __pyx_t_4, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_4 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;} } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L21_exception_handled; } __pyx_L22_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L6_error; __pyx_L21_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L27_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__22, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L6_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L19; } __pyx_L19:; } goto __pyx_L37; __pyx_L14_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L6_error; __pyx_L37:; } /* "src/llfuse/handlers.pxi":447 * break * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_buf, __pyx_v_acc_size); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L13_try_end; __pyx_L6_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":448 * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_22 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_22) { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":449 * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('readdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_22 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_22 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_22); } /* "src/llfuse/handlers.pxi":448 * acc_size += len_ * ret = fuse_reply_buf(req, buf, acc_size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L44; } /*exception exit:*/{ __pyx_L43_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_25 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_20, &__pyx_t_25); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_25); __pyx_t_22 = __pyx_lineno; __pyx_t_23 = __pyx_clineno; __pyx_t_24 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_20, __pyx_t_25); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_20 = 0; __pyx_t_25 = 0; __pyx_lineno = __pyx_t_22; __pyx_clineno = __pyx_t_23; __pyx_filename = __pyx_t_24; goto __pyx_L8_except_error; } __pyx_L44:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L7_exception_handled; } /* "src/llfuse/handlers.pxi":450 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readdir', e, req) * finally: */ __pyx_t_23 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_23) { __Pyx_AddTraceback("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_4, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 450; __pyx_clineno = __LINE__; goto __pyx_L8_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":451 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('readdir', e, req) # <<<<<<<<<<<<<< * finally: * if buf != NULL: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_readdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":450 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('readdir', e, req) * finally: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L55; } __pyx_L55:; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L7_exception_handled; } goto __pyx_L8_except_error; __pyx_L8_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L4_error; __pyx_L7_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L13_try_end:; } } /* "src/llfuse/handlers.pxi":453 * ret = handle_exc('readdir', e, req) * finally: * if buf != NULL: # <<<<<<<<<<<<<< * stdlib.free(buf) * */ /*finally:*/ { /*normal exit:*/{ __pyx_t_21 = ((__pyx_v_buf != NULL) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":454 * finally: * if buf != NULL: * stdlib.free(buf) # <<<<<<<<<<<<<< * * if ret != 0: */ free(__pyx_v_buf); goto __pyx_L56; } __pyx_L56:; goto __pyx_L5; } /*exception exit:*/{ __pyx_L4_error:; __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_25 = 0; __pyx_t_20 = 0; __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_25, &__pyx_t_20, &__pyx_t_9); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0)) __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_25); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_9); __pyx_t_23 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_26 = __pyx_filename; { /* "src/llfuse/handlers.pxi":453 * ret = handle_exc('readdir', e, req) * finally: * if buf != NULL: # <<<<<<<<<<<<<< * stdlib.free(buf) * */ __pyx_t_21 = ((__pyx_v_buf != NULL) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":454 * finally: * if buf != NULL: * stdlib.free(buf) # <<<<<<<<<<<<<< * * if ret != 0: */ free(__pyx_v_buf); goto __pyx_L59; } __pyx_L59:; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_25); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ExceptionReset(__pyx_t_25, __pyx_t_20, __pyx_t_9); } __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_1); __Pyx_ErrRestore(__pyx_t_3, __pyx_t_2, __pyx_t_1); __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_25 = 0; __pyx_t_20 = 0; __pyx_t_9 = 0; __pyx_lineno = __pyx_t_23; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_26; goto __pyx_L1_error; } __pyx_L5:; } /* "src/llfuse/handlers.pxi":456 * stdlib.free(buf) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_21 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_21) { /* "src/llfuse/handlers.pxi":457 * * if ret != 0: * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_14 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_14); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_27 = PyTuple_New(1+1); if (unlikely(!__pyx_t_27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_27); PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_27, 0+1, __pyx_t_14); __Pyx_GIVEREF(__pyx_t_14); __pyx_t_14 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_27, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_27 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_27); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_27, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_27, 0+__pyx_t_13, __pyx_kp_u_fuse_readdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_readdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_27, 1+__pyx_t_13, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_27, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_27); __pyx_t_27 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L60; } __pyx_L60:; /* "src/llfuse/handlers.pxi":422 * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_27); __Pyx_WriteUnraisable("llfuse.capi.fuse_readdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_next_); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":459 * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_releasedir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_releasedir", 0); /* "src/llfuse/handlers.pxi":462 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.releasedir(fi.fh) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":464 * try: * with lock: * operations.releasedir(fi.fh) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_releasedir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 464; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__23, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":465 * with lock: * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":466 * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":467 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('releasedir', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":466 * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":468 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('releasedir', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 468; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":469 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('releasedir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_releasedir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":468 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('releasedir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":471 * ret = handle_exc('releasedir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":472 * * if ret != 0: * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_releasedir_fuse_reply__fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 472; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":459 * log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":475 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_fsyncdir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_fsyncdir", 0); /* "src/llfuse/handlers.pxi":479 * cdef int ret * * try: # <<<<<<<<<<<<<< * with lock: * operations.fsyncdir(fi.fh, datasync != 0) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":481 * try: * with lock: * operations.fsyncdir(fi.fh, datasync != 0) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_fsyncdir); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyBool_FromLong((__pyx_v_datasync != 0)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 481; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__24, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":482 * with lock: * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":483 * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":484 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('fsyncdir', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":483 * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":485 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsyncdir', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 485; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":486 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('fsyncdir', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_fsyncdir, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":485 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('fsyncdir', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":488 * ret = handle_exc('fsyncdir', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":489 * * if ret != 0: * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":475 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":492 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef statvfs cstats */ static void __pyx_f_6llfuse_4capi_fuse_statfs(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino) { int __pyx_v_ret; struct statvfs __pyx_v_cstats; PyObject *__pyx_v_stats = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; char const *__pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_statfs", 0); /* "src/llfuse/handlers.pxi":497 * * # We don't set all the components * string.memset(&cstats, 0, sizeof(cstats)) # <<<<<<<<<<<<<< * try: * with lock: */ memset((&__pyx_v_cstats), 0, (sizeof(__pyx_v_cstats))); /* "src/llfuse/handlers.pxi":498 * # We don't set all the components * string.memset(&cstats, 0, sizeof(cstats)) * try: # <<<<<<<<<<<<<< * with lock: * stats = operations.statfs() */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":500 * try: * with lock: * stats = operations.statfs() # <<<<<<<<<<<<<< * * fill_statvfs(stats, &cstats) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_statfs); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_stats = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_13 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_14 = ((!(__pyx_t_13 != 0)) != 0); if (__pyx_t_14) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_7); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__25, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":502 * stats = operations.statfs() * * fill_statvfs(stats, &cstats) # <<<<<<<<<<<<<< * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: */ if (unlikely(!__pyx_v_stats)) { __Pyx_RaiseUnboundLocalError("stats"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_7 = __pyx_f_6llfuse_4capi_fill_statvfs(__pyx_v_stats, (&__pyx_v_cstats)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 502; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":503 * * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_statfs(__pyx_v_req, (&__pyx_v_cstats)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":504 * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_15) { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":505 * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('statfs', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 505; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_15 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 505; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_15); } /* "src/llfuse/handlers.pxi":504 * fill_statvfs(stats, &cstats) * ret = fuse_reply_statfs(req, &cstats) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_12 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_12, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_15 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_12, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_12 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_15; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":506 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('statfs', e, req) * */ __pyx_t_16 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 506; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":507 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('statfs', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_statfs, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":506 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('statfs', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":509 * ret = handle_exc('statfs', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_14 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_14) { /* "src/llfuse/handlers.pxi":510 * * if ret != 0: * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * IF TARGET_PLATFORM == 'darwin': */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_19 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_19); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_19); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_19); __Pyx_GIVEREF(__pyx_t_19); __pyx_t_19 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_statfs_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":492 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef statvfs cstats */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_stats); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":534 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_setxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, const char *__pyx_v_cvalue, size_t __pyx_v_size, int __pyx_v_flags) { int __pyx_v_ret; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_value = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; Py_ssize_t __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; PyObject *__pyx_t_20 = NULL; int __pyx_t_21; char const *__pyx_t_22; PyObject *__pyx_t_23 = NULL; PyObject *__pyx_t_24 = NULL; PyObject *__pyx_t_25 = NULL; PyObject *__pyx_t_26 = NULL; PyObject *__pyx_t_27 = NULL; PyObject *__pyx_t_28 = NULL; char const *__pyx_t_29; PyObject *__pyx_t_30 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_setxattr", 0); /* "src/llfuse/handlers.pxi":538 * cdef int ret * * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * value = PyBytes_FromStringAndSize(cvalue, size) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":539 * * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * value = PyBytes_FromStringAndSize(cvalue, size) * */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 539; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":540 * try: * name = PyBytes_FromString(cname) * value = PyBytes_FromStringAndSize(cvalue, size) # <<<<<<<<<<<<<< * * # Special case for deadlock debugging */ __pyx_t_4 = PyBytes_FromStringAndSize(__pyx_v_cvalue, __pyx_v_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_value = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":543 * * # Special case for deadlock debugging * if ino == FUSE_ROOT_ID and string.strcmp(cname, 'fuse_stacktrace') == 0: # <<<<<<<<<<<<<< * operations.stacktrace() * else: */ __pyx_t_6 = ((__pyx_v_ino == FUSE_ROOT_ID) != 0); if (__pyx_t_6) { } else { __pyx_t_5 = __pyx_t_6; goto __pyx_L12_bool_binop_done; } __pyx_t_6 = ((strcmp(__pyx_v_cname, __pyx_k_fuse_stacktrace) == 0) != 0); __pyx_t_5 = __pyx_t_6; __pyx_L12_bool_binop_done:; if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":544 * # Special case for deadlock debugging * if ino == FUSE_ROOT_ID and string.strcmp(cname, 'fuse_stacktrace') == 0: * operations.stacktrace() # <<<<<<<<<<<<<< * else: * IF TARGET_PLATFORM == 'freebsd': */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_stacktrace); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L11; } /*else*/ { /* "src/llfuse/handlers.pxi":552 * ELSE: * # Make sure we know all the flags * if flags & ~(xattr.XATTR_CREATE | xattr.XATTR_REPLACE): # <<<<<<<<<<<<<< * raise ValueError('unknown flag(s): %o' % flags) * */ __pyx_t_5 = ((__pyx_v_flags & (~(XATTR_CREATE | XATTR_REPLACE))) != 0); if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":553 * # Make sure we know all the flags * if flags & ~(xattr.XATTR_CREATE | xattr.XATTR_REPLACE): * raise ValueError('unknown flag(s): %o' % flags) # <<<<<<<<<<<<<< * * with lock: */ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = PyUnicode_Format(__pyx_kp_u_unknown_flag_s_o, __pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } /* "src/llfuse/handlers.pxi":555 * raise ValueError('unknown flag(s): %o' % flags) * * with lock: # <<<<<<<<<<<<<< * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: */ /*with:*/ { __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyObject_LookupSpecial(__pyx_t_7, __pyx_n_s_exit); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_8 = __Pyx_PyObject_LookupSpecial(__pyx_t_7, __pyx_n_s_enter); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L15_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (__pyx_t_10) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L15_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L15_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); /*try:*/ { /* "src/llfuse/handlers.pxi":556 * * with lock: * if flags & xattr.XATTR_CREATE: # Attribute must not exist # <<<<<<<<<<<<<< * try: * operations.getxattr(ino, name) */ __pyx_t_5 = ((__pyx_v_flags & XATTR_CREATE) != 0); if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":557 * with lock: * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: # <<<<<<<<<<<<<< * operations.getxattr(ino, name) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); /*try:*/ { /* "src/llfuse/handlers.pxi":558 * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: * operations.getxattr(ino, name) # <<<<<<<<<<<<<< * except FUSEError as e: * if e.errno != errno.ENOATTR: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_17 = 1; } } __pyx_t_18 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_18); if (__pyx_t_10) { PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = NULL; } PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_17, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_17, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_8 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_18, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 558; __pyx_clineno = __LINE__; goto __pyx_L30_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } /*else:*/ { /* "src/llfuse/handlers.pxi":563 * raise * else: * raise FUSEError(errno.EEXIST) # <<<<<<<<<<<<<< * * elif flags & xattr.XATTR_REPLACE: # Attribute must exist */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_18 = __Pyx_PyInt_From_int(EEXIST); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_18); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (!__pyx_t_8) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_18); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_18); __Pyx_GIVEREF(__pyx_t_18); __pyx_t_18 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 563; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} } __pyx_L30_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/handlers.pxi":559 * try: * operations.getxattr(ino, name) * except FUSEError as e: # <<<<<<<<<<<<<< * if e.errno != errno.ENOATTR: * raise */ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_19 = PyErr_ExceptionMatches(__pyx_t_7); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L32_except_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_4); __pyx_v_e = __pyx_t_4; /*try:*/ { /* "src/llfuse/handlers.pxi":560 * operations.getxattr(ino, name) * except FUSEError as e: * if e.errno != errno.ENOATTR: # <<<<<<<<<<<<<< * raise * else: */ __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_GOTREF(__pyx_t_18); __pyx_t_8 = __Pyx_PyInt_From_int(ENOATTR); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = PyObject_RichCompare(__pyx_t_18, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_20); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_20); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L43_error;} __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":561 * except FUSEError as e: * if e.errno != errno.ENOATTR: * raise # <<<<<<<<<<<<<< * else: * raise FUSEError(errno.EEXIST) */ __Pyx_GIVEREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_7, __pyx_t_4, __pyx_t_10); __pyx_t_7 = 0; __pyx_t_4 = 0; __pyx_t_10 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 561; __pyx_clineno = __LINE__; goto __pyx_L43_error;} } } /* "src/llfuse/handlers.pxi":559 * try: * operations.getxattr(ino, name) * except FUSEError as e: # <<<<<<<<<<<<<< * if e.errno != errno.ENOATTR: * raise */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L44; } /*exception exit:*/{ __pyx_L43_error:; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_26, &__pyx_t_27, &__pyx_t_28); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25) < 0)) __Pyx_ErrFetch(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25); __Pyx_XGOTREF(__pyx_t_23); __Pyx_XGOTREF(__pyx_t_24); __Pyx_XGOTREF(__pyx_t_25); __Pyx_XGOTREF(__pyx_t_26); __Pyx_XGOTREF(__pyx_t_27); __Pyx_XGOTREF(__pyx_t_28); __pyx_t_19 = __pyx_lineno; __pyx_t_21 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_26); __Pyx_XGIVEREF(__pyx_t_27); __Pyx_XGIVEREF(__pyx_t_28); __Pyx_ExceptionReset(__pyx_t_26, __pyx_t_27, __pyx_t_28); } __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ErrRestore(__pyx_t_23, __pyx_t_24, __pyx_t_25); __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_lineno = __pyx_t_19; __pyx_clineno = __pyx_t_21; __pyx_filename = __pyx_t_22; goto __pyx_L32_except_error; } __pyx_L44:; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L31_exception_handled; } goto __pyx_L32_except_error; __pyx_L32_except_error:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); goto __pyx_L21_error; __pyx_L31_exception_handled:; __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } goto __pyx_L29; } /* "src/llfuse/handlers.pxi":565 * raise FUSEError(errno.EEXIST) * * elif flags & xattr.XATTR_REPLACE: # Attribute must exist # <<<<<<<<<<<<<< * operations.getxattr(ino, name) * */ __pyx_t_5 = ((__pyx_v_flags & XATTR_REPLACE) != 0); if (__pyx_t_5) { /* "src/llfuse/handlers.pxi":566 * * elif flags & xattr.XATTR_REPLACE: # Attribute must exist * operations.getxattr(ino, name) # <<<<<<<<<<<<<< * * operations.setxattr(ino, name, value) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_20 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_17 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_20) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_17, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_17, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 566; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L29; } __pyx_L29:; /* "src/llfuse/handlers.pxi":568 * operations.getxattr(ino, name) * * operations.setxattr(ino, name, value) # <<<<<<<<<<<<<< * * ret = fuse_reply_err(req, 0) */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_setxattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_17 = 1; } } __pyx_t_20 = PyTuple_New(3+__pyx_t_17); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_20); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } PyTuple_SET_ITEM(__pyx_t_20, 0+__pyx_t_17, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_20, 1+__pyx_t_17, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __Pyx_INCREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_20, 2+__pyx_t_17, __pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); __pyx_t_8 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_20, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 568; __pyx_clineno = __LINE__; goto __pyx_L21_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L28_try_end; __pyx_L21_error:; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/llfuse/handlers.pxi":555 * raise ValueError('unknown flag(s): %o' % flags) * * with lock: # <<<<<<<<<<<<<< * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_4, &__pyx_t_20) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_20); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_10, __pyx_t_4, __pyx_t_20); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_16 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_16); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; if (__pyx_t_5 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} __pyx_t_6 = ((!(__pyx_t_5 != 0)) != 0); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ErrRestore(__pyx_t_10, __pyx_t_4, __pyx_t_20); __pyx_t_10 = 0; __pyx_t_4 = 0; __pyx_t_20 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;} } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; goto __pyx_L22_exception_handled; } __pyx_L23_except_error:; __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); goto __pyx_L3_error; __pyx_L22_exception_handled:; __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_L28_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_9) { __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__26, NULL); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } goto __pyx_L20; } __pyx_L20:; } goto __pyx_L53; __pyx_L15_error:; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L3_error; __pyx_L53:; } } __pyx_L11:; /* "src/llfuse/handlers.pxi":570 * operations.setxattr(ino, name, value) * * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0; /* "src/llfuse/handlers.pxi":571 * * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_20 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_20); __pyx_t_21 = PyErr_ExceptionMatches(__pyx_t_20); __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_20, &__pyx_t_4, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_20); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_e, __pyx_t_4); /*try:*/ { /* "src/llfuse/handlers.pxi":572 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('setxattr', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L59_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_21 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L59_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_21); } /* "src/llfuse/handlers.pxi":571 * * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L60; } /*exception exit:*/{ __pyx_L59_error:; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_11, &__pyx_t_16, &__pyx_t_15); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_13, &__pyx_t_12) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_13, &__pyx_t_12); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_15); __pyx_t_21 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_29 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_11, __pyx_t_16, __pyx_t_15); } __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_9, __pyx_t_13, __pyx_t_12); __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_12 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_lineno = __pyx_t_21; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_29; goto __pyx_L5_except_error; } __pyx_L60:; } __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":573 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setxattr', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_4, &__pyx_t_20) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 573; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_20); __Pyx_INCREF(__pyx_t_4); __Pyx_XDECREF_SET(__pyx_v_e, __pyx_t_4); /*try:*/ { /* "src/llfuse/handlers.pxi":574 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('setxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_setxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":573 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('setxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L71; } __pyx_L71:; } __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":576 * ret = handle_exc('setxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_6 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_6) { /* "src/llfuse/handlers.pxi":577 * * if ret != 0: * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * IF TARGET_PLATFORM == 'darwin': */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_error); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_18 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_18)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_18); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_18) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_30 = PyTuple_New(1+1); if (unlikely(!__pyx_t_30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_30); PyTuple_SET_ITEM(__pyx_t_30, 0, __pyx_t_18); __Pyx_GIVEREF(__pyx_t_18); __pyx_t_18 = NULL; PyTuple_SET_ITEM(__pyx_t_30, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_30, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_17 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_10))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_10); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_10, function); __pyx_t_17 = 1; } } __pyx_t_30 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_30); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_30, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_30, 0+__pyx_t_17, __pyx_kp_u_fuse_setxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_30, 1+__pyx_t_17, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_30, NULL); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_20); __Pyx_DECREF(__pyx_t_30); __pyx_t_30 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; goto __pyx_L72; } __pyx_L72:; /* "src/llfuse/handlers.pxi":534 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_18); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_30); __Pyx_WriteUnraisable("llfuse.capi.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_value); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":592 * fuse_getxattr(req, ino, cname, size) * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_getxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, size_t __pyx_v_size) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_getxattr", 0); /* "src/llfuse/handlers.pxi":597 * cdef ssize_t len_ * cdef char *cbuf * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":598 * cdef char *cbuf * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * buf = operations.getxattr(ino, name) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 598; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":600 * name = PyBytes_FromString(cname) * with lock: * buf = operations.getxattr(ino, name) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 600; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_13); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_13 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__27, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":601 * with lock: * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * * if size == 0: */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 601; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_17 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_17 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 601; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":603 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * * if size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: */ __pyx_t_16 = ((__pyx_v_size == 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":604 * * if size == 0: * ret = fuse_reply_xattr(req, len_) # <<<<<<<<<<<<<< * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_v_ret = fuse_reply_xattr(__pyx_v_req, __pyx_v_len_); goto __pyx_L29; } /* "src/llfuse/handlers.pxi":605 * if size == 0: * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * else: */ __pyx_t_16 = ((((size_t)__pyx_v_len_) <= __pyx_v_size) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":606 * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, errno.ERANGE) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); goto __pyx_L29; } /*else*/ { /* "src/llfuse/handlers.pxi":608 * ret = fuse_reply_buf(req, cbuf, len_) * else: * ret = fuse_reply_err(req, errno.ERANGE) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, ERANGE); } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; /* "src/llfuse/handlers.pxi":609 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":610 * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('getxattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 610; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 610; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":609 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":611 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getxattr', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 611; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":612 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('getxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_getxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":611 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('getxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L47; } __pyx_L47:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":614 * ret = handle_exc('getxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":615 * * if ret != 0: * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_12, __pyx_kp_u_fuse_getxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 615; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L48; } __pyx_L48:; /* "src/llfuse/handlers.pxi":592 * fuse_getxattr(req, ino, cname, size) * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * size_t size) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":617 * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_ */ static void __pyx_f_6llfuse_4capi_fuse_listxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, size_t __pyx_v_size) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cbuf; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; char const *__pyx_t_18; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; Py_ssize_t __pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_listxattr", 0); /* "src/llfuse/handlers.pxi":621 * cdef ssize_t len_ * cdef char *cbuf * try: # <<<<<<<<<<<<<< * with lock: * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":623 * try: * with lock: * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' # <<<<<<<<<<<<<< * * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_listxattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyBytes_Join(__pyx_kp_b__28, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyNumber_Add(__pyx_t_6, __pyx_kp_b__28); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_14 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_15 = ((!(__pyx_t_14 != 0)) != 0); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_12); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_12 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__29, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":625 * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * * PyBytes_AsStringAndSize(buf, &cbuf, &len_) # <<<<<<<<<<<<<< * * if len_ == 1: # No attributes */ if (unlikely(!__pyx_v_buf)) { __Pyx_RaiseUnboundLocalError("buf"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_16 = PyBytes_AsStringAndSize(__pyx_v_buf, (&__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_16 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 625; __pyx_clineno = __LINE__; goto __pyx_L3_error;} /* "src/llfuse/handlers.pxi":627 * PyBytes_AsStringAndSize(buf, &cbuf, &len_) * * if len_ == 1: # No attributes # <<<<<<<<<<<<<< * len_ = 0 * */ __pyx_t_15 = ((__pyx_v_len_ == 1) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":628 * * if len_ == 1: # No attributes * len_ = 0 # <<<<<<<<<<<<<< * * if size == 0: */ __pyx_v_len_ = 0; goto __pyx_L29; } __pyx_L29:; /* "src/llfuse/handlers.pxi":630 * len_ = 0 * * if size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: */ __pyx_t_15 = ((__pyx_v_size == 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":631 * * if size == 0: * ret = fuse_reply_xattr(req, len_) # <<<<<<<<<<<<<< * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) */ __pyx_v_ret = fuse_reply_xattr(__pyx_v_req, __pyx_v_len_); goto __pyx_L30; } /* "src/llfuse/handlers.pxi":632 * if size == 0: * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(req, cbuf, len_) * else: */ __pyx_t_15 = ((((size_t)__pyx_v_len_) <= __pyx_v_size) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":633 * ret = fuse_reply_xattr(req, len_) * elif len_ <= size: * ret = fuse_reply_buf(req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, errno.ERANGE) */ __pyx_v_ret = fuse_reply_buf(__pyx_v_req, __pyx_v_cbuf, __pyx_v_len_); goto __pyx_L30; } /*else*/ { /* "src/llfuse/handlers.pxi":635 * ret = fuse_reply_buf(req, cbuf, len_) * else: * ret = fuse_reply_err(req, errno.ERANGE) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, ERANGE); } __pyx_L30:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/llfuse/handlers.pxi":636 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = PyErr_ExceptionMatches(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_16) { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 636; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":637 * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('listxattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_16); } /* "src/llfuse/handlers.pxi":636 * else: * ret = fuse_reply_err(req, errno.ERANGE) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L37; } /*exception exit:*/{ __pyx_L36_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_13, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_16 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_13, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_13 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18; goto __pyx_L5_except_error; } __pyx_L37:; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":638 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('listxattr', e, req) * */ __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_12) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":639 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('listxattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_listxattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":638 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('listxattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":641 * ret = handle_exc('listxattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_15 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_15) { /* "src/llfuse/handlers.pxi":642 * * if ret != 0: * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_20 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_20 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_20)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_20); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_20) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __Pyx_GIVEREF(__pyx_t_20); __pyx_t_20 = NULL; PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_22 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_22 = 1; } } __pyx_t_21 = PyTuple_New(2+__pyx_t_22); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_21); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_21, 0+__pyx_t_22, __pyx_kp_u_fuse_listxattr_fuse_reply__faile); __Pyx_GIVEREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_21, 1+__pyx_t_22, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_21, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L49; } __pyx_L49:; /* "src/llfuse/handlers.pxi":617 * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_ */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_20); __Pyx_XDECREF(__pyx_t_21); __Pyx_WriteUnraisable("llfuse.capi.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_buf); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":644 * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: # <<<<<<<<<<<<<< * cdef int ret * try: */ static void __pyx_f_6llfuse_4capi_fuse_removexattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname) { int __pyx_v_ret; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; Py_ssize_t __pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; int __pyx_t_15; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_removexattr", 0); /* "src/llfuse/handlers.pxi":646 * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: * cdef int ret * try: # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":647 * cdef int ret * try: * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * operations.removexattr(ino, name) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":649 * name = PyBytes_FromString(cname) * with lock: * operations.removexattr(ino, name) # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * except FUSEError as e: */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_removexattr); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_12 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_12, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_12, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_13, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 649; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __pyx_t_7 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_15 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_16 = ((!(__pyx_t_15 != 0)) != 0); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_13); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_13 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__30, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":650 * with lock: * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; /* "src/llfuse/handlers.pxi":651 * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_17 = PyErr_ExceptionMatches(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_17) { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_13, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":652 * ret = fuse_reply_err(req, 0) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('removexattr', e, req) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_17 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_17 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 652; __pyx_clineno = __LINE__; goto __pyx_L34_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_17); } /* "src/llfuse/handlers.pxi":651 * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L35; } /*exception exit:*/{ __pyx_L34_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_14, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_17 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_14, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_14 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_17; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L5_except_error; } __pyx_L35:; } __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":653 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('removexattr', e, req) * */ __pyx_t_18 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 653; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_13); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":654 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('removexattr', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_removexattr, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":653 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('removexattr', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L46; } __pyx_L46:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":656 * ret = handle_exc('removexattr', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_16 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_16) { /* "src/llfuse/handlers.pxi":657 * * if ret != 0: * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_21 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_21 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_21)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_21); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_21) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_21); __Pyx_GIVEREF(__pyx_t_21); __pyx_t_21 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_7) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_12, __pyx_kp_u_fuse_removexattr_fuse_reply__fai); __Pyx_GIVEREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_12, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 657; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; goto __pyx_L47; } __pyx_L47:; /* "src/llfuse/handlers.pxi":644 * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: # <<<<<<<<<<<<<< * cdef int ret * try: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_21); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":659 * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ static void __pyx_f_6llfuse_4capi_fuse_access(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, int __pyx_v_mask) { int __pyx_v_ret; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_allowed = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; Py_ssize_t __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; int __pyx_t_17; int __pyx_t_18; int __pyx_t_19; char const *__pyx_t_20; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_access", 0); /* "src/llfuse/handlers.pxi":662 * cdef int ret * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * with lock: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":663 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * with lock: * allowed = operations.access(ino, mask, ctx) */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":665 * ctx = get_request_context(req) * with lock: * allowed = operations.access(ino, mask, ctx) # <<<<<<<<<<<<<< * if allowed: * ret = fuse_reply_err(req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_access); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_mask); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 665; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_allowed = __pyx_t_4; __pyx_t_4 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __pyx_t_8 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_14); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_15); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (__pyx_t_16 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_17 = ((!(__pyx_t_16 != 0)) != 0); if (__pyx_t_17) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_6, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_14 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__31, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L28; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L28:; } /* "src/llfuse/handlers.pxi":666 * with lock: * allowed = operations.access(ino, mask, ctx) * if allowed: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, 0) * else: */ if (unlikely(!__pyx_v_allowed)) { __Pyx_RaiseUnboundLocalError("allowed"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_17 = __Pyx_PyObject_IsTrue(__pyx_v_allowed); if (unlikely(__pyx_t_17 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L3_error;} if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":667 * allowed = operations.access(ino, mask, ctx) * if allowed: * ret = fuse_reply_err(req, 0) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(req, EPERM) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, 0); goto __pyx_L29; } /*else*/ { /* "src/llfuse/handlers.pxi":669 * ret = fuse_reply_err(req, 0) * else: * ret = fuse_reply_err(req, EPERM) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_err(__pyx_v_req, EPERM); } __pyx_L29:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; /* "src/llfuse/handlers.pxi":670 * else: * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_14 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __pyx_t_18 = PyErr_ExceptionMatches(__pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; if (__pyx_t_18) { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_6, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 670; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":671 * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('access', e, req) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_18 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_18 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 671; __pyx_clineno = __LINE__; goto __pyx_L35_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_18); } /* "src/llfuse/handlers.pxi":670 * else: * ret = fuse_reply_err(req, EPERM) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L36; } /*exception exit:*/{ __pyx_L35_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_15, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_18 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_15, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_15 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_18; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20; goto __pyx_L5_except_error; } __pyx_L36:; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":672 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('access', e, req) * */ __pyx_t_19 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_19) { __Pyx_AddTraceback("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_14) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 672; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_6); __pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/llfuse/handlers.pxi":673 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('access', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_access, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":672 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('access', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L47; } __pyx_L47:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":675 * ret = handle_exc('access', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/llfuse/handlers.pxi":676 * * if ret != 0: * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_12 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } if (!__pyx_t_12) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_22, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } __pyx_t_22 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_22); if (__pyx_t_8) { PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 0+__pyx_t_13, __pyx_kp_u_fuse_access_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_22, 1+__pyx_t_13, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_22, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 676; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L48; } __pyx_L48:; /* "src/llfuse/handlers.pxi":659 * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_22); __Pyx_WriteUnraisable("llfuse.capi.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_allowed); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/handlers.pxi":679 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *cname, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi) with gil: * cdef int ret */ static void __pyx_f_6llfuse_4capi_fuse_create(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_cname, mode_t __pyx_v_mode, struct fuse_file_info *__pyx_v_fi) { int __pyx_v_ret; struct fuse_entry_param __pyx_v_entry; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_attr = NULL; PyObject *__pyx_v_e = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; Py_ssize_t __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *(*__pyx_t_16)(PyObject *); uint64_t __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_t_20; int __pyx_t_21; int __pyx_t_22; char const *__pyx_t_23; PyObject *__pyx_t_24 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; #ifdef WITH_THREAD PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); #endif __Pyx_RefNannySetupContext("fuse_create", 0); /* "src/llfuse/handlers.pxi":684 * cdef fuse_entry_param entry * * try: # <<<<<<<<<<<<<< * ctx = get_request_context(req) * name = PyBytes_FromString(cname) */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/llfuse/handlers.pxi":685 * * try: * ctx = get_request_context(req) # <<<<<<<<<<<<<< * name = PyBytes_FromString(cname) * with lock: */ __pyx_t_4 = __pyx_f_6llfuse_4capi_get_request_context(__pyx_v_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_ctx = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":686 * try: * ctx = get_request_context(req) * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * with lock: * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) */ __pyx_t_4 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_v_name = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ /*with:*/ { __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_exit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = __Pyx_PyObject_LookupSpecial(__pyx_t_4, __pyx_n_s_enter); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (__pyx_t_8) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else { __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L11_error;} } __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/handlers.pxi":688 * name = PyBytes_FromString(cname) * with lock: * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) # <<<<<<<<<<<<<< * * # Cached file data does not need to be invalidated. */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6llfuse_4capi_operations, __pyx_n_s_create); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_parent); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_mode_t(__pyx_v_mode); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_fi->flags); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_13)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_13); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_14 = 1; } } __pyx_t_15 = PyTuple_New(5+__pyx_t_14); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_13) { PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_13); __Pyx_GIVEREF(__pyx_t_13); __pyx_t_13 = NULL; } PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_14, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_14, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_14, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_14, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __Pyx_INCREF(__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 4+__pyx_t_14, __pyx_v_ctx); __Pyx_GIVEREF(__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_12 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { PyObject* sequence = __pyx_t_4; #if CYTHON_COMPILING_IN_CPYTHON Py_ssize_t size = Py_SIZE(sequence); #else Py_ssize_t size = PySequence_Size(sequence); #endif if (unlikely(size != 2)) { if (size > 2) __Pyx_RaiseTooManyValuesError(2); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} } #if CYTHON_COMPILING_IN_CPYTHON if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_15 = PyTuple_GET_ITEM(sequence, 1); } else { __pyx_t_6 = PyList_GET_ITEM(sequence, 0); __pyx_t_15 = PyList_GET_ITEM(sequence, 1); } __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_15); #else __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_15 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_15); #endif __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { Py_ssize_t index = -1; __pyx_t_12 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_16 = Py_TYPE(__pyx_t_12)->tp_iternext; index = 0; __pyx_t_6 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_6)) goto __pyx_L25_unpacking_failed; __Pyx_GOTREF(__pyx_t_6); index = 1; __pyx_t_15 = __pyx_t_16(__pyx_t_12); if (unlikely(!__pyx_t_15)) goto __pyx_L25_unpacking_failed; __Pyx_GOTREF(__pyx_t_15); if (__Pyx_IternextUnpackEndCheck(__pyx_t_16(__pyx_t_12), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __pyx_t_16 = NULL; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L26_unpacking_done; __pyx_L25_unpacking_failed:; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_16 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __pyx_L26_unpacking_done:; } __pyx_t_17 = __Pyx_PyInt_As_uint64_t(__pyx_t_6); if (unlikely((__pyx_t_17 == (uint64_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 688; __pyx_clineno = __LINE__; goto __pyx_L17_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_v_fi->fh = __pyx_t_17; __pyx_v_attr = __pyx_t_15; __pyx_t_15 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L24_try_end; __pyx_L17_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_15, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_15, __pyx_t_6); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __Pyx_GOTREF(__pyx_t_18); __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_t_18); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; if (__pyx_t_19 < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} __pyx_t_20 = ((!(__pyx_t_19 != 0)) != 0); if (__pyx_t_20) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ErrRestore(__pyx_t_4, __pyx_t_15, __pyx_t_6); __pyx_t_4 = 0; __pyx_t_15 = 0; __pyx_t_6 = 0; {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L19_except_error;} } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L18_exception_handled; } __pyx_L19_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L3_error; __pyx_L18_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L24_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__32, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } goto __pyx_L16; } __pyx_L16:; } goto __pyx_L30; __pyx_L11_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L3_error; __pyx_L30:; } /* "src/llfuse/handlers.pxi":692 * # Cached file data does not need to be invalidated. * # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ * fi.keep_cache = 1 # <<<<<<<<<<<<<< * * fill_entry_param(attr, &entry) */ __pyx_v_fi->keep_cache = 1; /* "src/llfuse/handlers.pxi":694 * fi.keep_cache = 1 * * fill_entry_param(attr, &entry) # <<<<<<<<<<<<<< * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: */ if (unlikely(!__pyx_v_attr)) { __Pyx_RaiseUnboundLocalError("attr"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } __pyx_t_6 = __pyx_f_6llfuse_4capi_fill_entry_param(__pyx_v_attr, (&__pyx_v_entry)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 694; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":695 * * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) */ __pyx_v_ret = fuse_reply_create(__pyx_v_req, (&__pyx_v_entry), __pyx_v_fi); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L10_try_end; __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/llfuse/handlers.pxi":696 * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_FUSEError); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_21 = PyErr_ExceptionMatches(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (__pyx_t_21) { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_15, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 696; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_t_15); __pyx_v_e = __pyx_t_15; /*try:*/ { /* "src/llfuse/handlers.pxi":697 * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) # <<<<<<<<<<<<<< * except BaseException as e: * ret = handle_exc('create', e, req) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_21 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_21 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 697; __pyx_clineno = __LINE__; goto __pyx_L36_error;} __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_v_ret = fuse_reply_err(__pyx_v_req, __pyx_t_21); } /* "src/llfuse/handlers.pxi":696 * fill_entry_param(attr, &entry) * ret = fuse_reply_create(req, &entry, fi) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(req, e.errno) * except BaseException as e: */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L37; } /*exception exit:*/{ __pyx_L36_error:; __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_18 = 0; __pyx_t_24 = 0; __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_9, &__pyx_t_18, &__pyx_t_24); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_11, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_24); __pyx_t_21 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_23 = __pyx_filename; { __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_18, __pyx_t_24); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_11, __pyx_t_10); __pyx_t_5 = 0; __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_18 = 0; __pyx_t_24 = 0; __pyx_lineno = __pyx_t_21; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_23; goto __pyx_L5_except_error; } __pyx_L37:; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L4_exception_handled; } /* "src/llfuse/handlers.pxi":698 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('create', e, req) * */ __pyx_t_22 = PyErr_ExceptionMatches(__pyx_builtin_BaseException); if (__pyx_t_22) { __Pyx_AddTraceback("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_15, &__pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 698; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_15); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_15); __pyx_v_e = __pyx_t_15; /*try:*/ { /* "src/llfuse/handlers.pxi":699 * ret = fuse_reply_err(req, e.errno) * except BaseException as e: * ret = handle_exc('create', e, req) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = __pyx_f_6llfuse_4capi_handle_exc(__pyx_k_create, __pyx_v_e, __pyx_v_req); } /* "src/llfuse/handlers.pxi":698 * except FUSEError as e: * ret = fuse_reply_err(req, e.errno) * except BaseException as e: # <<<<<<<<<<<<<< * ret = handle_exc('create', e, req) * */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_e); __pyx_v_e = NULL; goto __pyx_L48; } __pyx_L48:; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L4_exception_handled; } goto __pyx_L5_except_error; __pyx_L5_except_error:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L4_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L10_try_end:; } /* "src/llfuse/handlers.pxi":701 * ret = handle_exc('create', e, req) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) */ __pyx_t_20 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/llfuse/handlers.pxi":702 * * if ret != 0: * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< */ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_12); __pyx_t_8 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_12))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_12); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_12, function); } } if (!__pyx_t_7) { __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_8); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_15); } else { __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_13, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; } __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; __pyx_t_14 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_14 = 1; } } __pyx_t_13 = PyTuple_New(2+__pyx_t_14); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); if (__pyx_t_12) { PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __Pyx_GIVEREF(__pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_13, 0+__pyx_t_14, __pyx_kp_u_fuse_create_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_13, 1+__pyx_t_14, __pyx_t_15); __Pyx_GIVEREF(__pyx_t_15); __pyx_t_15 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 702; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L49; } __pyx_L49:; /* "src/llfuse/handlers.pxi":679 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *cname, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi) with gil: * cdef int ret */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_15); __Pyx_WriteUnraisable("llfuse.capi.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_attr); __Pyx_XDECREF(__pyx_v_e); __Pyx_RefNannyFinishContext(); #ifdef WITH_THREAD PyGILState_Release(__pyx_gilstate_save); #endif } /* "src/llfuse/misc.pxi":13 * ''' * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): # <<<<<<<<<<<<<< * entry.ino = attr.st_ino * entry.generation = attr.generation */ static PyObject *__pyx_f_6llfuse_4capi_fill_entry_param(PyObject *__pyx_v_attr, struct fuse_entry_param *__pyx_v_entry) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; fuse_ino_t __pyx_t_2; unsigned long __pyx_t_3; double __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_entry_param", 0); /* "src/llfuse/misc.pxi":14 * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): * entry.ino = attr.st_ino # <<<<<<<<<<<<<< * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ino); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->ino = __pyx_t_2; /* "src/llfuse/misc.pxi":15 * cdef object fill_entry_param(object attr, fuse_entry_param* entry): * entry.ino = attr.st_ino * entry.generation = attr.generation # <<<<<<<<<<<<<< * entry.entry_timeout = attr.entry_timeout * entry.attr_timeout = attr.attr_timeout */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_generation); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_unsigned_long(__pyx_t_1); if (unlikely((__pyx_t_3 == (unsigned long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->generation = __pyx_t_3; /* "src/llfuse/misc.pxi":16 * entry.ino = attr.st_ino * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout # <<<<<<<<<<<<<< * entry.attr_timeout = attr.attr_timeout * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_entry_timeout); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->entry_timeout = __pyx_t_4; /* "src/llfuse/misc.pxi":17 * entry.generation = attr.generation * entry.entry_timeout = attr.entry_timeout * entry.attr_timeout = attr.attr_timeout # <<<<<<<<<<<<<< * * fill_c_stat(attr, &entry.attr) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_attr_timeout); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 17; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_entry->attr_timeout = __pyx_t_4; /* "src/llfuse/misc.pxi":19 * entry.attr_timeout = attr.attr_timeout * * fill_c_stat(attr, &entry.attr) # <<<<<<<<<<<<<< * * cdef object fill_c_stat(object attr, c_stat* stat): */ __pyx_t_1 = __pyx_f_6llfuse_4capi_fill_c_stat(__pyx_v_attr, (&__pyx_v_entry->attr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 19; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":13 * ''' * * cdef object fill_entry_param(object attr, fuse_entry_param* entry): # <<<<<<<<<<<<<< * entry.ino = attr.st_ino * entry.generation = attr.generation */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.fill_entry_param", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":21 * fill_c_stat(attr, &entry.attr) * * cdef object fill_c_stat(object attr, c_stat* stat): # <<<<<<<<<<<<<< * * # Under OS-X, c_stat has an additional st_flags field. The memset */ static PyObject *__pyx_f_6llfuse_4capi_fill_c_stat(PyObject *__pyx_v_attr, struct stat *__pyx_v_stat) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; ino_t __pyx_t_2; mode_t __pyx_t_3; nlink_t __pyx_t_4; uid_t __pyx_t_5; gid_t __pyx_t_6; dev_t __pyx_t_7; off_t __pyx_t_8; blksize_t __pyx_t_9; blkcnt_t __pyx_t_10; int __pyx_t_11; int __pyx_t_12; PyObject *__pyx_t_13 = NULL; time_t __pyx_t_14; long __pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_c_stat", 0); /* "src/llfuse/misc.pxi":27 * # platform check (although, admittedly, this explanatory comment * # make take even more space than the check would have taken). * string.memset(stat, 0, sizeof(c_stat)) # <<<<<<<<<<<<<< * * stat.st_ino = attr.st_ino */ memset(__pyx_v_stat, 0, (sizeof(struct stat))); /* "src/llfuse/misc.pxi":29 * string.memset(stat, 0, sizeof(c_stat)) * * stat.st_ino = attr.st_ino # <<<<<<<<<<<<<< * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ino); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_ino_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 29; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_ino = __pyx_t_2; /* "src/llfuse/misc.pxi":30 * * stat.st_ino = attr.st_ino * stat.st_mode = attr.st_mode # <<<<<<<<<<<<<< * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_mode_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (mode_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 30; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_mode = __pyx_t_3; /* "src/llfuse/misc.pxi":31 * stat.st_ino = attr.st_ino * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink # <<<<<<<<<<<<<< * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_nlink); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_nlink_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (nlink_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 31; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_nlink = __pyx_t_4; /* "src/llfuse/misc.pxi":32 * stat.st_mode = attr.st_mode * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid # <<<<<<<<<<<<<< * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_uid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyInt_As_uid_t(__pyx_t_1); if (unlikely((__pyx_t_5 == (uid_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_uid = __pyx_t_5; /* "src/llfuse/misc.pxi":33 * stat.st_nlink = attr.st_nlink * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid # <<<<<<<<<<<<<< * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_gid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_gid_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (gid_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 33; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_gid = __pyx_t_6; /* "src/llfuse/misc.pxi":34 * stat.st_uid = attr.st_uid * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev # <<<<<<<<<<<<<< * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_rdev); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_PyInt_As_dev_t(__pyx_t_1); if (unlikely((__pyx_t_7 == (dev_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 34; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_rdev = __pyx_t_7; /* "src/llfuse/misc.pxi":35 * stat.st_gid = attr.st_gid * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size # <<<<<<<<<<<<<< * stat.st_blksize = attr.st_blksize * stat.st_blocks = attr.st_blocks */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_size); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = __Pyx_PyInt_As_off_t(__pyx_t_1); if (unlikely((__pyx_t_8 == (off_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 35; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_size = __pyx_t_8; /* "src/llfuse/misc.pxi":36 * stat.st_rdev = attr.st_rdev * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize # <<<<<<<<<<<<<< * stat.st_blocks = attr.st_blocks * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_blksize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyInt_As_blksize_t(__pyx_t_1); if (unlikely((__pyx_t_9 == (blksize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_blksize = __pyx_t_9; /* "src/llfuse/misc.pxi":37 * stat.st_size = attr.st_size * stat.st_blksize = attr.st_blksize * stat.st_blocks = attr.st_blocks # <<<<<<<<<<<<<< * * if attr.st_atime_ns is not None: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_blocks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyInt_As_blkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_10 == (blkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_blocks = __pyx_t_10; /* "src/llfuse/misc.pxi":39 * stat.st_blocks = attr.st_blocks * * if attr.st_atime_ns is not None: # <<<<<<<<<<<<<< * stat.st_atime = attr.st_atime_ns / 10**9 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_11 = (__pyx_t_1 != Py_None); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_12 = (__pyx_t_11 != 0); if (__pyx_t_12) { /* "src/llfuse/misc.pxi":40 * * if attr.st_atime_ns is not None: * stat.st_atime = attr.st_atime_ns / 10**9 # <<<<<<<<<<<<<< * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) * else: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = __Pyx_PyNumber_Divide(__pyx_t_1, __pyx_int_1000000000); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_13); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_stat->st_atime = __pyx_t_14; /* "src/llfuse/misc.pxi":41 * if attr.st_atime_ns is not None: * stat.st_atime = attr.st_atime_ns / 10**9 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_atime = attr.st_atime */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_1 = PyNumber_Remainder(__pyx_t_13, __pyx_int_1000000000); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 41; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_ATIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":43 * SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) * else: * stat.st_atime = attr.st_atime # <<<<<<<<<<<<<< * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_1); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_atime = __pyx_t_14; /* "src/llfuse/misc.pxi":44 * else: * stat.st_atime = attr.st_atime * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) # <<<<<<<<<<<<<< * * if attr.st_ctime_ns is not None: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_atime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_atime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = PyNumber_Subtract(__pyx_t_1, __pyx_t_13); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_13 = PyNumber_Multiply(__pyx_t_16, __pyx_float_1e9); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_13); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 44; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; SET_ATIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L3:; /* "src/llfuse/misc.pxi":46 * SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) * * if attr.st_ctime_ns is not None: # <<<<<<<<<<<<<< * stat.st_ctime = attr.st_ctime_ns / 10**9 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 46; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_12 = (__pyx_t_13 != Py_None); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_11 = (__pyx_t_12 != 0); if (__pyx_t_11) { /* "src/llfuse/misc.pxi":47 * * if attr.st_ctime_ns is not None: * stat.st_ctime = attr.st_ctime_ns / 10**9 # <<<<<<<<<<<<<< * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) * else: */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = __Pyx_PyNumber_Divide(__pyx_t_13, __pyx_int_1000000000); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_16); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 47; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_v_stat->st_ctime = __pyx_t_14; /* "src/llfuse/misc.pxi":48 * if attr.st_ctime_ns is not None: * stat.st_ctime = attr.st_ctime_ns / 10**9 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_ctime = attr.st_ctime */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_13 = PyNumber_Remainder(__pyx_t_16, __pyx_int_1000000000); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_13); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 48; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; SET_CTIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L4; } /*else*/ { /* "src/llfuse/misc.pxi":50 * SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) * else: * stat.st_ctime = attr.st_ctime # <<<<<<<<<<<<<< * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) * */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_13); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_v_stat->st_ctime = __pyx_t_14; /* "src/llfuse/misc.pxi":51 * else: * stat.st_ctime = attr.st_ctime * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) # <<<<<<<<<<<<<< * * if attr.st_mtime_ns is not None: */ __pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_ctime); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __pyx_t_16 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_ctime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = PyNumber_Subtract(__pyx_t_13, __pyx_t_16); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_16 = PyNumber_Multiply(__pyx_t_1, __pyx_float_1e9); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_16); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; SET_CTIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L4:; /* "src/llfuse/misc.pxi":53 * SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) * * if attr.st_mtime_ns is not None: # <<<<<<<<<<<<<< * stat.st_mtime = attr.st_mtime_ns / 10**9 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 53; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_11 = (__pyx_t_16 != Py_None); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_12 = (__pyx_t_11 != 0); if (__pyx_t_12) { /* "src/llfuse/misc.pxi":54 * * if attr.st_mtime_ns is not None: * stat.st_mtime = attr.st_mtime_ns / 10**9 # <<<<<<<<<<<<<< * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) * else: */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = __Pyx_PyNumber_Divide(__pyx_t_16, __pyx_int_1000000000); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_1); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->st_mtime = __pyx_t_14; /* "src/llfuse/misc.pxi":55 * if attr.st_mtime_ns is not None: * stat.st_mtime = attr.st_mtime_ns / 10**9 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) # <<<<<<<<<<<<<< * else: * stat.st_mtime = attr.st_mtime */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime_ns); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_16 = PyNumber_Remainder(__pyx_t_1, __pyx_int_1000000000); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_16); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 55; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; SET_MTIME_NS(__pyx_v_stat, __pyx_t_15); goto __pyx_L5; } /*else*/ { /* "src/llfuse/misc.pxi":57 * SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) * else: * stat.st_mtime = attr.st_mtime # <<<<<<<<<<<<<< * SET_MTIME_NS(stat, (attr.st_mtime - stat.st_mtime) * 1e9) * */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_14 = __Pyx_PyInt_As_time_t(__pyx_t_16); if (unlikely((__pyx_t_14 == (time_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 57; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __pyx_v_stat->st_mtime = __pyx_t_14; /* "src/llfuse/misc.pxi":58 * else: * stat.st_mtime = attr.st_mtime * SET_MTIME_NS(stat, (attr.st_mtime - stat.st_mtime) * 1e9) # <<<<<<<<<<<<<< * * */ __pyx_t_16 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_st_mtime); if (unlikely(!__pyx_t_16)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_16); __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_stat->st_mtime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_13 = PyNumber_Subtract(__pyx_t_16, __pyx_t_1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_13); __Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyNumber_Multiply(__pyx_t_13, __pyx_float_1e9); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_MTIME_NS(__pyx_v_stat, __pyx_t_15); } __pyx_L5:; /* "src/llfuse/misc.pxi":21 * fill_c_stat(attr, &entry.attr) * * cdef object fill_c_stat(object attr, c_stat* stat): # <<<<<<<<<<<<<< * * # Under OS-X, c_stat has an additional st_flags field. The memset */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_13); __Pyx_XDECREF(__pyx_t_16); __Pyx_AddTraceback("llfuse.capi.fill_c_stat", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":61 * * * cdef object fill_statvfs(object attr, statvfs* stat): # <<<<<<<<<<<<<< * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize */ static PyObject *__pyx_f_6llfuse_4capi_fill_statvfs(PyObject *__pyx_v_attr, struct statvfs *__pyx_v_stat) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; fsblkcnt_t __pyx_t_3; fsfilcnt_t __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fill_statvfs", 0); /* "src/llfuse/misc.pxi":62 * * cdef object fill_statvfs(object attr, statvfs* stat): * stat.f_bsize = attr.f_bsize # <<<<<<<<<<<<<< * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 62; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 62; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bsize = __pyx_t_2; /* "src/llfuse/misc.pxi":63 * cdef object fill_statvfs(object attr, statvfs* stat): * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize # <<<<<<<<<<<<<< * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_frsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 63; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_frsize = __pyx_t_2; /* "src/llfuse/misc.pxi":64 * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks # <<<<<<<<<<<<<< * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_blocks); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 64; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 64; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_blocks = __pyx_t_3; /* "src/llfuse/misc.pxi":65 * stat.f_frsize = attr.f_frsize * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree # <<<<<<<<<<<<<< * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bfree); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 65; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 65; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bfree = __pyx_t_3; /* "src/llfuse/misc.pxi":66 * stat.f_blocks = attr.f_blocks * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail # <<<<<<<<<<<<<< * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_bavail); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (fsblkcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_bavail = __pyx_t_3; /* "src/llfuse/misc.pxi":67 * stat.f_bfree = attr.f_bfree * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files # <<<<<<<<<<<<<< * stat.f_ffree = attr.f_ffree * stat.f_favail = attr.f_favail */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_files); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 67; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 67; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_files = __pyx_t_4; /* "src/llfuse/misc.pxi":68 * stat.f_bavail = attr.f_bavail * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree # <<<<<<<<<<<<<< * stat.f_favail = attr.f_favail * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_ffree); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 68; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 68; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_ffree = __pyx_t_4; /* "src/llfuse/misc.pxi":69 * stat.f_files = attr.f_files * stat.f_ffree = attr.f_ffree * stat.f_favail = attr.f_favail # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_attr, __pyx_n_s_f_favail); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (fsfilcnt_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_stat->f_favail = __pyx_t_4; /* "src/llfuse/misc.pxi":61 * * * cdef object fill_statvfs(object attr, statvfs* stat): # <<<<<<<<<<<<<< * stat.f_bsize = attr.f_bsize * stat.f_frsize = attr.f_frsize */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.fill_statvfs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":72 * * * cdef int handle_exc(char* fn, object e, fuse_req_t req): # <<<<<<<<<<<<<< * '''Try to call fuse_reply_err and terminate main loop''' * */ static int __pyx_f_6llfuse_4capi_handle_exc(CYTHON_UNUSED char *__pyx_v_fn, CYTHON_UNUSED PyObject *__pyx_v_e, fuse_req_t __pyx_v_req) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("handle_exc", 0); /* "src/llfuse/misc.pxi":77 * global exc_info * * if not exc_info: # <<<<<<<<<<<<<< * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = ((!__pyx_t_1) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":78 * * if not exc_info: * exc_info = sys.exc_info() # <<<<<<<<<<<<<< * log.debug('handler raised exception, sending SIGTERM to self.') * kill(getpid(), SIGTERM) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_exc_info); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (__pyx_t_4) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else { __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":79 * if not exc_info: * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') # <<<<<<<<<<<<<< * kill(getpid(), SIGTERM) * else: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":80 * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') * kill(getpid(), SIGTERM) # <<<<<<<<<<<<<< * else: * log.exception('Exception after kill:') */ kill(getpid(), SIGTERM); goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":82 * kill(getpid(), SIGTERM) * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * if req is NULL: */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_exception); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L3:; /* "src/llfuse/misc.pxi":84 * log.exception('Exception after kill:') * * if req is NULL: # <<<<<<<<<<<<<< * return 0 * else: */ __pyx_t_2 = ((__pyx_v_req == NULL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":85 * * if req is NULL: * return 0 # <<<<<<<<<<<<<< * else: * return fuse_reply_err(req, errno.EIO) */ __pyx_r = 0; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":87 * return 0 * else: * return fuse_reply_err(req, errno.EIO) # <<<<<<<<<<<<<< * * cdef object get_request_context(fuse_req_t req): */ __pyx_r = fuse_reply_err(__pyx_v_req, EIO); goto __pyx_L0; } /* "src/llfuse/misc.pxi":72 * * * cdef int handle_exc(char* fn, object e, fuse_req_t req): # <<<<<<<<<<<<<< * '''Try to call fuse_reply_err and terminate main loop''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("llfuse.capi.handle_exc", __pyx_clineno, __pyx_lineno, __pyx_filename, 0); __pyx_r = 0; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":89 * return fuse_reply_err(req, errno.EIO) * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ static PyObject *__pyx_f_6llfuse_4capi_get_request_context(fuse_req_t __pyx_v_req) { const struct fuse_ctx *__pyx_v_context; PyObject *__pyx_v_ctx = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_request_context", 0); /* "src/llfuse/misc.pxi":94 * cdef const_fuse_ctx* context * * context = fuse_req_ctx(req) # <<<<<<<<<<<<<< * ctx = RequestContext() * ctx.pid = context.pid */ __pyx_v_context = fuse_req_ctx(__pyx_v_req); /* "src/llfuse/misc.pxi":95 * * context = fuse_req_ctx(req) * ctx = RequestContext() # <<<<<<<<<<<<<< * ctx.pid = context.pid * ctx.uid = context.uid */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_RequestContext); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 95; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":96 * context = fuse_req_ctx(req) * ctx = RequestContext() * ctx.pid = context.pid # <<<<<<<<<<<<<< * ctx.uid = context.uid * ctx.gid = context.gid */ __pyx_t_1 = __Pyx_PyInt_From_pid_t(__pyx_v_context->pid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_pid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":97 * ctx = RequestContext() * ctx.pid = context.pid * ctx.uid = context.uid # <<<<<<<<<<<<<< * ctx.gid = context.gid * ctx.umask = context.umask */ __pyx_t_1 = __Pyx_PyInt_From_uid_t(__pyx_v_context->uid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 97; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_uid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 97; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":98 * ctx.pid = context.pid * ctx.uid = context.uid * ctx.gid = context.gid # <<<<<<<<<<<<<< * ctx.umask = context.umask * */ __pyx_t_1 = __Pyx_PyInt_From_gid_t(__pyx_v_context->gid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_gid, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 98; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":99 * ctx.uid = context.uid * ctx.gid = context.gid * ctx.umask = context.umask # <<<<<<<<<<<<<< * * return ctx */ __pyx_t_1 = __Pyx_PyInt_From_mode_t(__pyx_v_context->umask); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_v_ctx, __pyx_n_s_umask, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 99; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":101 * ctx.umask = context.umask * * return ctx # <<<<<<<<<<<<<< * * cdef void init_fuse_ops(): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_ctx); __pyx_r = __pyx_v_ctx; goto __pyx_L0; /* "src/llfuse/misc.pxi":89 * return fuse_reply_err(req, errno.EIO) * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.get_request_context", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_ctx); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":103 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ static void __pyx_f_6llfuse_4capi_init_fuse_ops(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init_fuse_ops", 0); /* "src/llfuse/misc.pxi":106 * '''Initialize fuse_lowlevel_ops structure''' * * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) # <<<<<<<<<<<<<< * * fuse_ops.init = fuse_init */ memset((&__pyx_v_6llfuse_4capi_fuse_ops), 0, (sizeof(struct fuse_lowlevel_ops))); /* "src/llfuse/misc.pxi":108 * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) * * fuse_ops.init = fuse_init # <<<<<<<<<<<<<< * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup */ __pyx_v_6llfuse_4capi_fuse_ops.init = __pyx_f_6llfuse_4capi_fuse_init; /* "src/llfuse/misc.pxi":109 * * fuse_ops.init = fuse_init * fuse_ops.destroy = fuse_destroy # <<<<<<<<<<<<<< * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget */ __pyx_v_6llfuse_4capi_fuse_ops.destroy = __pyx_f_6llfuse_4capi_fuse_destroy; /* "src/llfuse/misc.pxi":110 * fuse_ops.init = fuse_init * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup # <<<<<<<<<<<<<< * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr */ __pyx_v_6llfuse_4capi_fuse_ops.lookup = __pyx_f_6llfuse_4capi_fuse_lookup; /* "src/llfuse/misc.pxi":111 * fuse_ops.destroy = fuse_destroy * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget # <<<<<<<<<<<<<< * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr */ __pyx_v_6llfuse_4capi_fuse_ops.forget = __pyx_f_6llfuse_4capi_fuse_forget; /* "src/llfuse/misc.pxi":112 * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr # <<<<<<<<<<<<<< * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink */ __pyx_v_6llfuse_4capi_fuse_ops.getattr = __pyx_f_6llfuse_4capi_fuse_getattr; /* "src/llfuse/misc.pxi":113 * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr # <<<<<<<<<<<<<< * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod */ __pyx_v_6llfuse_4capi_fuse_ops.setattr = __pyx_f_6llfuse_4capi_fuse_setattr; /* "src/llfuse/misc.pxi":114 * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink # <<<<<<<<<<<<<< * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir */ __pyx_v_6llfuse_4capi_fuse_ops.readlink = __pyx_f_6llfuse_4capi_fuse_readlink; /* "src/llfuse/misc.pxi":115 * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod # <<<<<<<<<<<<<< * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink */ __pyx_v_6llfuse_4capi_fuse_ops.mknod = __pyx_f_6llfuse_4capi_fuse_mknod; /* "src/llfuse/misc.pxi":116 * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir # <<<<<<<<<<<<<< * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir */ __pyx_v_6llfuse_4capi_fuse_ops.mkdir = __pyx_f_6llfuse_4capi_fuse_mkdir; /* "src/llfuse/misc.pxi":117 * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink # <<<<<<<<<<<<<< * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink */ __pyx_v_6llfuse_4capi_fuse_ops.unlink = __pyx_f_6llfuse_4capi_fuse_unlink; /* "src/llfuse/misc.pxi":118 * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir # <<<<<<<<<<<<<< * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename */ __pyx_v_6llfuse_4capi_fuse_ops.rmdir = __pyx_f_6llfuse_4capi_fuse_rmdir; /* "src/llfuse/misc.pxi":119 * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink # <<<<<<<<<<<<<< * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link */ __pyx_v_6llfuse_4capi_fuse_ops.symlink = __pyx_f_6llfuse_4capi_fuse_symlink; /* "src/llfuse/misc.pxi":120 * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename # <<<<<<<<<<<<<< * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open */ __pyx_v_6llfuse_4capi_fuse_ops.rename = __pyx_f_6llfuse_4capi_fuse_rename; /* "src/llfuse/misc.pxi":121 * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link # <<<<<<<<<<<<<< * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read */ __pyx_v_6llfuse_4capi_fuse_ops.link = __pyx_f_6llfuse_4capi_fuse_link; /* "src/llfuse/misc.pxi":122 * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open # <<<<<<<<<<<<<< * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write */ __pyx_v_6llfuse_4capi_fuse_ops.open = __pyx_f_6llfuse_4capi_fuse_open; /* "src/llfuse/misc.pxi":123 * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read # <<<<<<<<<<<<<< * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush */ __pyx_v_6llfuse_4capi_fuse_ops.read = __pyx_f_6llfuse_4capi_fuse_read; /* "src/llfuse/misc.pxi":124 * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write # <<<<<<<<<<<<<< * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release */ __pyx_v_6llfuse_4capi_fuse_ops.write = __pyx_f_6llfuse_4capi_fuse_write; /* "src/llfuse/misc.pxi":125 * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush # <<<<<<<<<<<<<< * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync */ __pyx_v_6llfuse_4capi_fuse_ops.flush = __pyx_f_6llfuse_4capi_fuse_flush; /* "src/llfuse/misc.pxi":126 * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release # <<<<<<<<<<<<<< * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir */ __pyx_v_6llfuse_4capi_fuse_ops.release = __pyx_f_6llfuse_4capi_fuse_release; /* "src/llfuse/misc.pxi":127 * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync # <<<<<<<<<<<<<< * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir */ __pyx_v_6llfuse_4capi_fuse_ops.fsync = __pyx_f_6llfuse_4capi_fuse_fsync; /* "src/llfuse/misc.pxi":128 * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir # <<<<<<<<<<<<<< * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir */ __pyx_v_6llfuse_4capi_fuse_ops.opendir = __pyx_f_6llfuse_4capi_fuse_opendir; /* "src/llfuse/misc.pxi":129 * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir # <<<<<<<<<<<<<< * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir */ __pyx_v_6llfuse_4capi_fuse_ops.readdir = __pyx_f_6llfuse_4capi_fuse_readdir; /* "src/llfuse/misc.pxi":130 * fuse_ops.opendir = fuse_opendir * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir # <<<<<<<<<<<<<< * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs */ __pyx_v_6llfuse_4capi_fuse_ops.releasedir = __pyx_f_6llfuse_4capi_fuse_releasedir; /* "src/llfuse/misc.pxi":131 * fuse_ops.readdir = fuse_readdir * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir # <<<<<<<<<<<<<< * fuse_ops.statfs = fuse_statfs * IF TARGET_PLATFORM == 'darwin': */ __pyx_v_6llfuse_4capi_fuse_ops.fsyncdir = __pyx_f_6llfuse_4capi_fuse_fsyncdir; /* "src/llfuse/misc.pxi":132 * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'darwin': * fuse_ops.setxattr = fuse_setxattr_darwin */ __pyx_v_6llfuse_4capi_fuse_ops.statfs = __pyx_f_6llfuse_4capi_fuse_statfs; /* "src/llfuse/misc.pxi":137 * fuse_ops.getxattr = fuse_getxattr_darwin * ELSE: * fuse_ops.setxattr = fuse_setxattr # <<<<<<<<<<<<<< * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr */ __pyx_v_6llfuse_4capi_fuse_ops.setxattr = __pyx_f_6llfuse_4capi_fuse_setxattr; /* "src/llfuse/misc.pxi":138 * ELSE: * fuse_ops.setxattr = fuse_setxattr * fuse_ops.getxattr = fuse_getxattr # <<<<<<<<<<<<<< * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr */ __pyx_v_6llfuse_4capi_fuse_ops.getxattr = __pyx_f_6llfuse_4capi_fuse_getxattr; /* "src/llfuse/misc.pxi":139 * fuse_ops.setxattr = fuse_setxattr * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr # <<<<<<<<<<<<<< * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access */ __pyx_v_6llfuse_4capi_fuse_ops.listxattr = __pyx_f_6llfuse_4capi_fuse_listxattr; /* "src/llfuse/misc.pxi":140 * fuse_ops.getxattr = fuse_getxattr * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr # <<<<<<<<<<<<<< * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create */ __pyx_v_6llfuse_4capi_fuse_ops.removexattr = __pyx_f_6llfuse_4capi_fuse_removexattr; /* "src/llfuse/misc.pxi":141 * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access # <<<<<<<<<<<<<< * fuse_ops.create = fuse_create * */ __pyx_v_6llfuse_4capi_fuse_ops.access = __pyx_f_6llfuse_4capi_fuse_access; /* "src/llfuse/misc.pxi":142 * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create # <<<<<<<<<<<<<< * * cdef make_fuse_args(list args, fuse_args* f_args): */ __pyx_v_6llfuse_4capi_fuse_ops.create = __pyx_f_6llfuse_4capi_fuse_create; /* "src/llfuse/misc.pxi":103 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "src/llfuse/misc.pxi":144 * fuse_ops.create = fuse_create * * cdef make_fuse_args(list args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ static PyObject *__pyx_f_6llfuse_4capi_make_fuse_args(PyObject *__pyx_v_args, struct fuse_args *__pyx_v_f_args) { char *__pyx_v_arg; int __pyx_v_i; Py_ssize_t __pyx_v_size; PyObject *__pyx_v_args_new = NULL; PyObject *__pyx_v_el = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; int __pyx_t_13; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("make_fuse_args", 0); __Pyx_INCREF(__pyx_v_args); /* "src/llfuse/misc.pxi":149 * cdef ssize_t size * * args_new = [ b'Python-LLFUSE' ] # <<<<<<<<<<<<<< * for el in args: * if not isinstance(el, str_t): */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_b_Python_LLFUSE); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_kp_b_Python_LLFUSE); __Pyx_GIVEREF(__pyx_kp_b_Python_LLFUSE); __pyx_v_args_new = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":150 * * args_new = [ b'Python-LLFUSE' ] * for el in args: # <<<<<<<<<<<<<< * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') */ if (unlikely(__pyx_v_args == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/misc.pxi":151 * args_new = [ b'Python-LLFUSE' ] * for el in args: * if not isinstance(el, str_t): # <<<<<<<<<<<<<< * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_IsInstance(__pyx_v_el, __pyx_t_3); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":152 * for el in args: * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":153 * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') # <<<<<<<<<<<<<< * args_new.append(el.encode('us-ascii')) * args = args_new */ __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_kp_b_o); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 153; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":154 * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) # <<<<<<<<<<<<<< * args = args_new * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_el, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_t_7); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/llfuse/misc.pxi":150 * * args_new = [ b'Python-LLFUSE' ] * for el in args: # <<<<<<<<<<<<<< * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":155 * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) * args = args_new # <<<<<<<<<<<<<< * * f_args.argc = len(args) */ __Pyx_INCREF(__pyx_v_args_new); __Pyx_DECREF_SET(__pyx_v_args, __pyx_v_args_new); /* "src/llfuse/misc.pxi":157 * args = args_new * * f_args.argc = len(args) # <<<<<<<<<<<<<< * if f_args.argc == 0: * f_args.argv = NULL */ __pyx_t_2 = PyList_GET_SIZE(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 157; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_f_args->argc = ((int)__pyx_t_2); /* "src/llfuse/misc.pxi":158 * * f_args.argc = len(args) * if f_args.argc == 0: # <<<<<<<<<<<<<< * f_args.argv = NULL * return */ __pyx_t_5 = ((__pyx_v_f_args->argc == 0) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":159 * f_args.argc = len(args) * if f_args.argc == 0: * f_args.argv = NULL # <<<<<<<<<<<<<< * return * */ __pyx_v_f_args->argv = NULL; /* "src/llfuse/misc.pxi":160 * if f_args.argc == 0: * f_args.argv = NULL * return # <<<<<<<<<<<<<< * * f_args.allocated = 1 */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":162 * return * * f_args.allocated = 1 # <<<<<<<<<<<<<< * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) * */ __pyx_v_f_args->allocated = 1; /* "src/llfuse/misc.pxi":163 * * f_args.allocated = 1 * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) # <<<<<<<<<<<<<< * * if f_args.argv is NULL: */ __pyx_v_f_args->argv = ((char **)calloc(__pyx_v_f_args->argc, (sizeof(char *)))); /* "src/llfuse/misc.pxi":165 * f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) * * if f_args.argv is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_5 = ((__pyx_v_f_args->argv == NULL) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":166 * * if f_args.argv is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_8 = PyErr_NoMemory(); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L7; } __pyx_L7:; /* "src/llfuse/misc.pxi":168 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) */ { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/llfuse/misc.pxi":169 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) */ __pyx_t_12 = 0; __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_COMPILING_IN_CPYTHON __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_7); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L8_error;} #else __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L8_error;} #endif __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_7); __pyx_t_7 = 0; __pyx_v_i = __pyx_t_12; __pyx_t_12 = (__pyx_t_12 + 1); /* "src/llfuse/misc.pxi":170 * try: * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) # <<<<<<<<<<<<<< * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * */ __pyx_t_13 = PyBytes_AsStringAndSize(__pyx_v_el, (&__pyx_v_arg), ((Py_ssize_t *)(&__pyx_v_size))); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 170; __pyx_clineno = __LINE__; goto __pyx_L8_error;} /* "src/llfuse/misc.pxi":171 * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) # <<<<<<<<<<<<<< * * if f_args.argv[i] is NULL: */ (__pyx_v_f_args->argv[__pyx_v_i]) = ((char *)malloc(((__pyx_v_size + 1) * (sizeof(char))))); /* "src/llfuse/misc.pxi":173 * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * * if f_args.argv[i] is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_5 = (((__pyx_v_f_args->argv[__pyx_v_i]) == NULL) != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":174 * * if f_args.argv[i] is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * string.strncpy(f_args.argv[i], arg, size+1) */ __pyx_t_8 = PyErr_NoMemory(); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 174; __pyx_clineno = __LINE__; goto __pyx_L8_error;} goto __pyx_L18; } __pyx_L18:; /* "src/llfuse/misc.pxi":176 * cpython.exc.PyErr_NoMemory() * * string.strncpy(f_args.argv[i], arg, size+1) # <<<<<<<<<<<<<< * except: * for i in range(f_args.argc): */ strncpy((__pyx_v_f_args->argv[__pyx_v_i]), __pyx_v_arg, (__pyx_v_size + 1)); /* "src/llfuse/misc.pxi":169 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size) * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L15_try_end; __pyx_L8_error:; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":177 * * string.strncpy(f_args.argv[i], arg, size+1) * except: # <<<<<<<<<<<<<< * for i in range(f_args.argc): * # Freeing a NULL pointer (if this element has not been allocated */ /*except:*/ { __Pyx_AddTraceback("llfuse.capi.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 177; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_3); /* "src/llfuse/misc.pxi":178 * string.strncpy(f_args.argv[i], arg, size+1) * except: * for i in range(f_args.argc): # <<<<<<<<<<<<<< * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. */ __pyx_t_12 = __pyx_v_f_args->argc; for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) { __pyx_v_i = __pyx_t_13; /* "src/llfuse/misc.pxi":181 * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. * stdlib.free(f_args.argv[i]) # <<<<<<<<<<<<<< * stdlib.free(f_args.argv) * raise */ free((__pyx_v_f_args->argv[__pyx_v_i])); } /* "src/llfuse/misc.pxi":182 * # yet) is fine. * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) # <<<<<<<<<<<<<< * raise * */ free(__pyx_v_f_args->argv); /* "src/llfuse/misc.pxi":183 * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) * raise # <<<<<<<<<<<<<< * * cdef class Lock: */ __Pyx_GIVEREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ErrRestore(__pyx_t_1, __pyx_t_7, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_7 = 0; __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 183; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;} } __pyx_L10_except_error:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L1_error; __pyx_L15_try_end:; } /* "src/llfuse/misc.pxi":144 * fuse_ops.create = fuse_create * * cdef make_fuse_args(list args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_args_new); __Pyx_XDECREF(__pyx_v_el); __Pyx_XDECREF(__pyx_v_args); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":191 * ''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* Python wrapper */ static int __pyx_pw_6llfuse_4capi_4Lock_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6llfuse_4capi_4Lock_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock___init__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6llfuse_4capi_4Lock___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/llfuse/misc.pxi":192 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":191 * ''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.Lock.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":195 * 'provided instance instead.') * * def acquire(self, timeout=None): # <<<<<<<<<<<<<< * '''Acquire global lock * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_3acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_2acquire[] = "Lock.acquire(self, timeout=None)\nAcquire global lock\n\n If *timeout* is not None, and the lock could not be acquired\n after waiting for *timeout* seconds, return False. Otherwise\n return True.\n "; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_3acquire(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_timeout = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("acquire (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_timeout,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_None); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_timeout); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "acquire") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 195; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_timeout = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("acquire", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 195; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_2acquire(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_timeout); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_2acquire(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_timeout) { int __pyx_v_ret; int __pyx_v_timeout_c; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("acquire", 0); /* "src/llfuse/misc.pxi":206 * cdef int timeout_c * * if timeout is None: # <<<<<<<<<<<<<< * timeout_c = 0 * else: */ __pyx_t_1 = (__pyx_v_timeout == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":207 * * if timeout is None: * timeout_c = 0 # <<<<<<<<<<<<<< * else: * timeout_c = timeout */ __pyx_v_timeout_c = 0; goto __pyx_L3; } /*else*/ { /* "src/llfuse/misc.pxi":209 * timeout_c = 0 * else: * timeout_c = timeout # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_timeout); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 209; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_timeout_c = __pyx_t_3; } __pyx_L3:; /* "src/llfuse/misc.pxi":211 * timeout_c = timeout * * with nogil: # <<<<<<<<<<<<<< * ret = acquire(timeout_c) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":212 * * with nogil: * ret = acquire(timeout_c) # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = acquire(__pyx_v_timeout_c); } /* "src/llfuse/misc.pxi":211 * timeout_c = timeout * * with nogil: # <<<<<<<<<<<<<< * ret = acquire(timeout_c) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "src/llfuse/misc.pxi":214 * ret = acquire(timeout_c) * * if ret == 0: # <<<<<<<<<<<<<< * return True * elif ret == ETIMEDOUT and timeout != 0: */ __pyx_t_2 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":215 * * if ret == 0: * return True # <<<<<<<<<<<<<< * elif ret == ETIMEDOUT and timeout != 0: * return False */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; } /* "src/llfuse/misc.pxi":216 * if ret == 0: * return True * elif ret == ETIMEDOUT and timeout != 0: # <<<<<<<<<<<<<< * return False * elif ret == EDEADLK: */ __pyx_t_1 = ((__pyx_v_ret == ETIMEDOUT) != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L8_bool_binop_done; } __pyx_t_4 = PyObject_RichCompare(__pyx_v_timeout, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 216; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 216; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __pyx_t_1; __pyx_L8_bool_binop_done:; if (__pyx_t_2) { /* "src/llfuse/misc.pxi":217 * return True * elif ret == ETIMEDOUT and timeout != 0: * return False # <<<<<<<<<<<<<< * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; } /* "src/llfuse/misc.pxi":218 * elif ret == ETIMEDOUT and timeout != 0: * return False * elif ret == EDEADLK: # <<<<<<<<<<<<<< * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: */ __pyx_t_2 = ((__pyx_v_ret == EDEADLK) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":219 * return False * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":220 * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: # <<<<<<<<<<<<<< * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: */ __pyx_t_2 = ((__pyx_v_ret == EPROTO) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":221 * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":222 * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_2 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":223 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":225 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def release(self): */ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } if (!__pyx_t_7) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 225; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":195 * 'provided instance instead.') * * def acquire(self, timeout=None): # <<<<<<<<<<<<<< * '''Acquire global lock * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.Lock.acquire", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":227 * raise RuntimeError(strerror(ret)) * * def release(self): # <<<<<<<<<<<<<< * '''Release global lock''' * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_5release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_4release[] = "Lock.release(self)\nRelease global lock"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_5release(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("release (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_4release(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_4release(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { int __pyx_v_ret; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("release", 0); /* "src/llfuse/misc.pxi":231 * * cdef int ret * with nogil: # <<<<<<<<<<<<<< * ret = release() * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":232 * cdef int ret * with nogil: * ret = release() # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = release(); } /* "src/llfuse/misc.pxi":231 * * cdef int ret * with nogil: # <<<<<<<<<<<<<< * ret = release() * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "src/llfuse/misc.pxi":234 * ret = release() * * if ret == 0: # <<<<<<<<<<<<<< * return * elif ret == EPERM: */ __pyx_t_1 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":235 * * if ret == 0: * return # <<<<<<<<<<<<<< * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":236 * if ret == 0: * return * elif ret == EPERM: # <<<<<<<<<<<<<< * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: */ __pyx_t_1 = ((__pyx_v_ret == EPERM) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":237 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":238 * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_1 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":239 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":241 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def yield_(self, count=1): */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_5) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_2); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 241; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":227 * raise RuntimeError(strerror(ret)) * * def release(self): # <<<<<<<<<<<<<< * '''Release global lock''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.Lock.release", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":243 * raise RuntimeError(strerror(ret)) * * def yield_(self, count=1): # <<<<<<<<<<<<<< * '''Yield global lock to a different thread * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_7yield_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_6yield_[] = "Lock.yield_(self, count=1)\nYield global lock to a different thread\n\n The *count* argument may be used to yield the lock up to\n *count* times if there are still other threads waiting for the\n lock.\n "; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_7yield_(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_count = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("yield_ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_count,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)__pyx_int_1); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_count); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "yield_") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_count = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("yield_", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.yield_", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_6yield_(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_count); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_6yield_(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, PyObject *__pyx_v_count) { int __pyx_v_ret; int __pyx_v_count_c; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("yield_", 0); /* "src/llfuse/misc.pxi":254 * cdef int count_c * * count_c = count # <<<<<<<<<<<<<< * with nogil: * ret = c_yield(count_c) */ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_count); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 254; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_count_c = __pyx_t_1; /* "src/llfuse/misc.pxi":255 * * count_c = count * with nogil: # <<<<<<<<<<<<<< * ret = c_yield(count_c) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":256 * count_c = count * with nogil: * ret = c_yield(count_c) # <<<<<<<<<<<<<< * * if ret == 0: */ __pyx_v_ret = c_yield(__pyx_v_count_c); } /* "src/llfuse/misc.pxi":255 * * count_c = count * with nogil: # <<<<<<<<<<<<<< * ret = c_yield(count_c) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "src/llfuse/misc.pxi":258 * ret = c_yield(count_c) * * if ret == 0: # <<<<<<<<<<<<<< * return * elif ret == EPERM: */ __pyx_t_2 = ((__pyx_v_ret == 0) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":259 * * if ret == 0: * return # <<<<<<<<<<<<<< * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":260 * if ret == 0: * return * elif ret == EPERM: # <<<<<<<<<<<<<< * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: */ __pyx_t_2 = ((__pyx_v_ret == EPERM) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":261 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":262 * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: # <<<<<<<<<<<<<< * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: */ __pyx_t_2 = ((__pyx_v_ret == EPROTO) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":263 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":264 * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: # <<<<<<<<<<<<<< * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: */ __pyx_t_2 = ((__pyx_v_ret == ENOMSG) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":265 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":266 * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: # <<<<<<<<<<<<<< * raise RuntimeError("Lock not initialized") * else: */ __pyx_t_2 = ((__pyx_v_ret == EINVAL) != 0); if (__pyx_t_2) { /* "src/llfuse/misc.pxi":267 * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/misc.pxi":269 * raise RuntimeError("Lock not initialized") * else: * raise RuntimeError(strerror(ret)) # <<<<<<<<<<<<<< * * def __enter__(self): */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_ret); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (!__pyx_t_6) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_3); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/misc.pxi":243 * raise RuntimeError(strerror(ret)) * * def yield_(self, count=1): # <<<<<<<<<<<<<< * '''Yield global lock to a different thread * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.Lock.yield_", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":271 * raise RuntimeError(strerror(ret)) * * def __enter__(self): # <<<<<<<<<<<<<< * self.acquire() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_8__enter__[] = "Lock.__enter__(self)"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_9__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_8__enter__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_8__enter__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__enter__", 0); /* "src/llfuse/misc.pxi":272 * * def __enter__(self): * self.acquire() # <<<<<<<<<<<<<< * * def __exit__(self, exc_type, exc_val, exc_tb): */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_acquire); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":271 * raise RuntimeError(strerror(ret)) * * def __enter__(self): # <<<<<<<<<<<<<< * self.acquire() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.Lock.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":274 * self.acquire() * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.release() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_4Lock_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4Lock_10__exit__[] = "Lock.__exit__(self, exc_type, exc_val, exc_tb)"; static PyObject *__pyx_pw_6llfuse_4capi_4Lock_11__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_exc_type = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_val = 0; CYTHON_UNUSED PyObject *__pyx_v_exc_tb = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_exc_type,&__pyx_n_s_exc_val,&__pyx_n_s_exc_tb,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_val)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_exc_tb)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__exit__") < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_exc_type = values[0]; __pyx_v_exc_val = values[1]; __pyx_v_exc_tb = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.Lock.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_4Lock_10__exit__(((struct __pyx_obj_6llfuse_4capi_Lock *)__pyx_v_self), __pyx_v_exc_type, __pyx_v_exc_val, __pyx_v_exc_tb); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4Lock_10__exit__(struct __pyx_obj_6llfuse_4capi_Lock *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc_type, CYTHON_UNUSED PyObject *__pyx_v_exc_val, CYTHON_UNUSED PyObject *__pyx_v_exc_tb) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 0); /* "src/llfuse/misc.pxi":275 * * def __exit__(self, exc_type, exc_val, exc_tb): * self.release() # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_release); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 275; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":274 * self.acquire() * * def __exit__(self, exc_type, exc_val, exc_tb): # <<<<<<<<<<<<<< * self.release() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.Lock.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":281 * '''Context manager to execute code while the global lock is released''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* Python wrapper */ static int __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager___init__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_6llfuse_4capi_13NoLockManager___init__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/llfuse/misc.pxi":282 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/misc.pxi":281 * '''Context manager to execute code while the global lock is released''' * * def __init__(self): # <<<<<<<<<<<<<< * raise TypeError('You should not instantiate this class, use the ' * 'provided instance instead.') */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":285 * 'provided instance instead.') * * def __enter__ (self): # <<<<<<<<<<<<<< * lock.release() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_13NoLockManager_2__enter__[] = "NoLockManager.__enter__(self)"; static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__enter__ (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_2__enter__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__enter__", 0); /* "src/llfuse/misc.pxi":286 * * def __enter__ (self): * lock.release() # <<<<<<<<<<<<<< * * def __exit__(self, *a): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_release); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":285 * 'provided instance instead.') * * def __enter__ (self): # <<<<<<<<<<<<<< * lock.release() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__enter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":288 * lock.release() * * def __exit__(self, *a): # <<<<<<<<<<<<<< * lock.acquire() * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_13NoLockManager_4__exit__[] = "NoLockManager.__exit__(self, *a)"; static PyObject *__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { CYTHON_UNUSED PyObject *__pyx_v_a = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__exit__ (wrapper)", 0); if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__exit__", 0))) return NULL; __Pyx_INCREF(__pyx_args); __pyx_v_a = __pyx_args; __pyx_r = __pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(((struct __pyx_obj_6llfuse_4capi_NoLockManager *)__pyx_v_self), __pyx_v_a); /* function exit code */ __Pyx_XDECREF(__pyx_v_a); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_13NoLockManager_4__exit__(CYTHON_UNUSED struct __pyx_obj_6llfuse_4capi_NoLockManager *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_a) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__exit__", 0); /* "src/llfuse/misc.pxi":289 * * def __exit__(self, *a): * lock.acquire() # <<<<<<<<<<<<<< * * def _notify_loop(): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_lock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_acquire); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 289; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":288 * lock.release() * * def __exit__(self, *a): # <<<<<<<<<<<<<< * lock.acquire() * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi.NoLockManager.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_1_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi__notify_loop[] = "_notify_loop()\nRead notifications from queue and send to FUSE kernel module"; static PyMethodDef __pyx_mdef_6llfuse_4capi_1_notify_loop = {"_notify_loop", (PyCFunction)__pyx_pw_6llfuse_4capi_1_notify_loop, METH_NOARGS, __pyx_doc_6llfuse_4capi__notify_loop}; static PyObject *__pyx_pw_6llfuse_4capi_1_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_notify_loop (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi__notify_loop(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi__notify_loop(CYTHON_UNUSED PyObject *__pyx_self) { Py_ssize_t __pyx_v_len_; fuse_ino_t __pyx_v_ino; char *__pyx_v_cname; PyObject *__pyx_v_req = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; fuse_ino_t __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_notify_loop", 0); /* "src/llfuse/misc.pxi":298 * cdef char *cname * * while True: # <<<<<<<<<<<<<< * req = _notify_queue.get() * if req is None: */ while (1) { /* "src/llfuse/misc.pxi":299 * * while True: * req = _notify_queue.get() # <<<<<<<<<<<<<< * if req is None: * return */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_get); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 299; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_req, __pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":300 * while True: * req = _notify_queue.get() * if req is None: # <<<<<<<<<<<<<< * return * */ __pyx_t_4 = (__pyx_v_req == Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":301 * req = _notify_queue.get() * if req is None: * return # <<<<<<<<<<<<<< * * if isinstance(req, inval_inode_req): */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; } /* "src/llfuse/misc.pxi":303 * return * * if isinstance(req, inval_inode_req): # <<<<<<<<<<<<<< * ino = req.inode * if req.attr_only: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_inode_req); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = PyObject_IsInstance(__pyx_v_req, __pyx_t_1); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = (__pyx_t_5 != 0); if (__pyx_t_4) { /* "src/llfuse/misc.pxi":304 * * if isinstance(req, inval_inode_req): * ino = req.inode # <<<<<<<<<<<<<< * if req.attr_only: * with nogil: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_inode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 304; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ino = __pyx_t_6; /* "src/llfuse/misc.pxi":305 * if isinstance(req, inval_inode_req): * ino = req.inode * if req.attr_only: # <<<<<<<<<<<<<< * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_attr_only); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_4) { /* "src/llfuse/misc.pxi":306 * ino = req.inode * if req.attr_only: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":307 * if req.attr_only: * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) # <<<<<<<<<<<<<< * else: * with nogil: */ fuse_lowlevel_notify_inval_inode(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, -1, 0); } /* "src/llfuse/misc.pxi":306 * ino = req.inode * if req.attr_only: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L12; } __pyx_L12:; } } goto __pyx_L7; } /*else*/ { /* "src/llfuse/misc.pxi":309 * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":310 * else: * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) # <<<<<<<<<<<<<< * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) */ fuse_lowlevel_notify_inval_inode(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, 0, 0); } /* "src/llfuse/misc.pxi":309 * fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L17; } __pyx_L17:; } } } __pyx_L7:; goto __pyx_L6; } /* "src/llfuse/misc.pxi":311 * with nogil: * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_entry_req); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 311; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyObject_IsInstance(__pyx_v_req, __pyx_t_1); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 311; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/llfuse/misc.pxi":312 * fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) # <<<<<<<<<<<<<< * ino = req.inode_p * with nogil: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = PyBytes_AsStringAndSize(__pyx_t_1, (&__pyx_v_cname), ((Py_ssize_t *)(&__pyx_v_len_))); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 312; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/misc.pxi":313 * elif isinstance(req, inval_entry_req): * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p # <<<<<<<<<<<<<< * with nogil: * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_req, __pyx_n_s_inode_p); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_PyInt_As_fuse_ino_t(__pyx_t_1); if (unlikely((__pyx_t_6 == (fuse_ino_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v_ino = __pyx_t_6; /* "src/llfuse/misc.pxi":314 * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/misc.pxi":315 * ino = req.inode_p * with nogil: * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) # <<<<<<<<<<<<<< * else: * raise RuntimeError("Weird request received: %r", req) */ fuse_lowlevel_notify_inval_entry(__pyx_v_6llfuse_4capi_channel, __pyx_v_ino, __pyx_v_cname, __pyx_v_len_); } /* "src/llfuse/misc.pxi":314 * PyBytes_AsStringAndSize(req.name, &cname, &len_) * ino = req.inode_p * with nogil: # <<<<<<<<<<<<<< * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } goto __pyx_L6; } /*else*/ { /* "src/llfuse/misc.pxi":317 * fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) * else: * raise RuntimeError("Weird request received: %r", req) # <<<<<<<<<<<<<< * * cdef str2bytes(s): */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_kp_u_Weird_request_received_r); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_kp_u_Weird_request_received_r); __Pyx_GIVEREF(__pyx_kp_u_Weird_request_received_r); __Pyx_INCREF(__pyx_v_req); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_req); __Pyx_GIVEREF(__pyx_v_req); __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[1]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_L6:; } /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("llfuse.capi._notify_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_req); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":319 * raise RuntimeError("Weird request received: %r", req) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes * */ static PyObject *__pyx_f_6llfuse_4capi_str2bytes(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("str2bytes", 0); /* "src/llfuse/misc.pxi":326 * ''' * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return s * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":327 * * if PY_MAJOR_VERSION < 3: * return s # <<<<<<<<<<<<<< * else: * return s.encode(fse, 'surrogateescape') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":329 * return s * else: * return s.encode(fse, 'surrogateescape') # <<<<<<<<<<<<<< * * cdef bytes2str(s): */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_fse); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 329; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "src/llfuse/misc.pxi":319 * raise RuntimeError("Weird request received: %r", req) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/misc.pxi":331 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str * */ static PyObject *__pyx_f_6llfuse_4capi_bytes2str(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bytes2str", 0); /* "src/llfuse/misc.pxi":338 * ''' * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * return s * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/misc.pxi":339 * * if PY_MAJOR_VERSION < 3: * return s # <<<<<<<<<<<<<< * else: * return s.decode(fse, 'surrogateescape') */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_s); __pyx_r = __pyx_v_s; goto __pyx_L0; } /*else*/ { /* "src/llfuse/misc.pxi":341 * return s * else: * return s.decode(fse, 'surrogateescape') # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_decode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_fse); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); __pyx_t_4 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 341; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; } /* "src/llfuse/misc.pxi":331 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_3listdir(PyObject *__pyx_self, PyObject *__pyx_v_path); /*proto*/ static char __pyx_doc_6llfuse_4capi_2listdir[] = "listdir(path)\nLike `os.listdir`, but releases the GIL.\n\n This function returns an iterator over the directory entries in\n *path*. The returned values are of type :ref:`str\n ` in both Python 2.x and 3.x.\n\n In Python 2.x :class:`str` is equivalent to `bytes` so all names\n can be represented. In Python 3.x, surrogate escape coding (cf.\n `PEP 383 `_) is used for\n directory names that do not have a string representation.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_3listdir = {"listdir", (PyCFunction)__pyx_pw_6llfuse_4capi_3listdir, METH_O, __pyx_doc_6llfuse_4capi_2listdir}; static PyObject *__pyx_pw_6llfuse_4capi_3listdir(PyObject *__pyx_self, PyObject *__pyx_v_path) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("listdir (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_2listdir(__pyx_self, ((PyObject *)__pyx_v_path)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_2listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path) { DIR *__pyx_v_dirp; struct dirent __pyx_v_ent; struct dirent *__pyx_v_res; int __pyx_v_ret; char *__pyx_v_buf; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_names = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("listdir", 0); /* "src/llfuse/fuse_api.pxi":27 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 27; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":28 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef dirent.DIR* dirp */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":36 * cdef char* buf * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * buf = path_b * */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 36; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":37 * * path_b = str2bytes(path) * buf = path_b # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_buf = ((char *)__pyx_t_4); /* "src/llfuse/fuse_api.pxi":39 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = dirent.opendir(buf) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":40 * * with nogil: * dirp = dirent.opendir(buf) # <<<<<<<<<<<<<< * * if dirp == NULL: */ __pyx_v_dirp = opendir(__pyx_v_buf); } /* "src/llfuse/fuse_api.pxi":39 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = dirent.opendir(buf) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "src/llfuse/fuse_api.pxi":42 * dirp = dirent.opendir(buf) * * if dirp == NULL: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_dirp == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":43 * * if dirp == NULL: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * names = list() */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } if (!__pyx_t_8) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":45 * raise OSError(errno.errno, strerror(errno.errno), path) * * names = list() # <<<<<<<<<<<<<< * while True: * errno.errno = 0 */ __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 45; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_v_names = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; /* "src/llfuse/fuse_api.pxi":46 * * names = list() * while True: # <<<<<<<<<<<<<< * errno.errno = 0 * with nogil: */ while (1) { /* "src/llfuse/fuse_api.pxi":47 * names = list() * while True: * errno.errno = 0 # <<<<<<<<<<<<<< * with nogil: * ret = dirent.readdir_r(dirp, &ent, &res) */ errno = 0; /* "src/llfuse/fuse_api.pxi":48 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * ret = dirent.readdir_r(dirp, &ent, &res) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":49 * errno.errno = 0 * with nogil: * ret = dirent.readdir_r(dirp, &ent, &res) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = readdir_r(__pyx_v_dirp, (&__pyx_v_ent), (&__pyx_v_res)); } /* "src/llfuse/fuse_api.pxi":48 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * ret = dirent.readdir_r(dirp, &ent, &res) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L14; } __pyx_L14:; } } /* "src/llfuse/fuse_api.pxi":51 * ret = dirent.readdir_r(dirp, &ent, &res) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: */ __pyx_t_3 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":52 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * if res is NULL: * break */ __pyx_t_5 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_9 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_9); __pyx_t_7 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_7) { __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_6); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":53 * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: # <<<<<<<<<<<<<< * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: */ __pyx_t_3 = ((__pyx_v_res == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":54 * raise OSError(errno.errno, strerror(errno.errno), path) * if res is NULL: * break # <<<<<<<<<<<<<< * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: * continue */ goto __pyx_L9_break; } /* "src/llfuse/fuse_api.pxi":55 * if res is NULL: * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: # <<<<<<<<<<<<<< * continue * */ __pyx_t_2 = ((strcmp(__pyx_v_ent.d_name, __pyx_k__49) == 0) != 0); if (!__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L18_bool_binop_done; } __pyx_t_2 = ((strcmp(__pyx_v_ent.d_name, __pyx_k__50) == 0) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L18_bool_binop_done:; if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":56 * break * if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: * continue # <<<<<<<<<<<<<< * * names.append(bytes2str(PyBytes_FromString(ent.d_name))) */ goto __pyx_L8_continue; } /* "src/llfuse/fuse_api.pxi":58 * continue * * names.append(bytes2str(PyBytes_FromString(ent.d_name))) # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyBytes_FromString(__pyx_v_ent.d_name); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); __pyx_t_1 = __pyx_f_6llfuse_4capi_bytes2str(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_10 = __Pyx_PyList_Append(__pyx_v_names, __pyx_t_1); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 58; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_L8_continue:; } __pyx_L9_break:; /* "src/llfuse/fuse_api.pxi":60 * names.append(bytes2str(PyBytes_FromString(ent.d_name))) * * with nogil: # <<<<<<<<<<<<<< * dirent.closedir(dirp) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":61 * * with nogil: * dirent.closedir(dirp) # <<<<<<<<<<<<<< * * return names */ closedir(__pyx_v_dirp); } /* "src/llfuse/fuse_api.pxi":60 * names.append(bytes2str(PyBytes_FromString(ent.d_name))) * * with nogil: # <<<<<<<<<<<<<< * dirent.closedir(dirp) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } /* "src/llfuse/fuse_api.pxi":63 * dirent.closedir(dirp) * * return names # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_names); __pyx_r = __pyx_v_names; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("llfuse.capi.listdir", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_names); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_5setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_4setxattr[] = "setxattr(path, name, bytes value, namespace=u'user')\nSet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. *value* has to be of type `bytes`.\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast the `os.setxattr` function from the standard library,\n the method provided by Python-LLFUSE is also available for non-Linux\n systems.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_5setxattr = {"setxattr", (PyCFunction)__pyx_pw_6llfuse_4capi_5setxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4setxattr}; static PyObject *__pyx_pw_6llfuse_4capi_5setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_value = 0; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_value,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 2); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setxattr") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; __pyx_v_value = ((PyObject*)values[2]); __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 1, "value", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_4setxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_value, __pyx_v_namespace); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_4setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cvalue; char *__pyx_v_cpath; char *__pyx_v_cname; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; char *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setxattr", 0); /* "src/llfuse/fuse_api.pxi":81 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 81; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":82 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":84 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str_t): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_name, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { /* "src/llfuse/fuse_api.pxi":85 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":87 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_1 = __pyx_v_namespace; __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":89 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef int ret */ __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 89; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); /* "src/llfuse/fuse_api.pxi":88 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":104 * cnamespace = xattr.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":105 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_name_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":106 * path_b = str2bytes(path) * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_5 = PyBytes_AsStringAndSize(__pyx_v_value, (&__pyx_v_cvalue), (&__pyx_v_len_)); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 106; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":107 * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cpath = ((char *)__pyx_t_6); /* "src/llfuse/fuse_api.pxi":108 * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_PyObject_AsString(__pyx_v_name_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cname = ((char *)__pyx_t_6); /* "src/llfuse/fuse_api.pxi":111 * * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_set_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":116 * cvalue, len_) * ELSE: * ret = xattr.setxattr(cpath, cname, cvalue, len_, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = setxattr(__pyx_v_cpath, __pyx_v_cname, __pyx_v_cvalue, __pyx_v_len_, 0); } /* "src/llfuse/fuse_api.pxi":111 * * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_set_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L10; } __pyx_L10:; } } /* "src/llfuse/fuse_api.pxi":118 * ret = xattr.setxattr(cpath, cname, cvalue, len_, 0) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":119 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_9) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 119; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("llfuse.capi.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_7getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_6getxattr[] = "getxattr(path, name, int size_guess=128, namespace=u'user')\nGet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. Returns a value of type `bytes`.\n\n If the caller knows the approximate size of the attribute value,\n it should be supplied in *size_guess*. If the guess turns out\n to be wrong, the system call has to be carried out three times\n (the first call will fail, the second determines the size and\n the third finally gets the value).\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast the `os.setxattr` function from the standard library,\n the method provided by Python-LLFUSE is also available for non-Linux\n systems.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_7getxattr = {"getxattr", (PyCFunction)__pyx_pw_6llfuse_4capi_7getxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_6getxattr}; static PyObject *__pyx_pw_6llfuse_4capi_7getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; int __pyx_v_size_guess; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_size_guess,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_size_guess); if (value) { values[2] = value; kw_args--; } } case 3: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getxattr") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; if (values[2]) { __pyx_v_size_guess = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_size_guess == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } else { __pyx_v_size_guess = ((int)128); } __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_6getxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_size_guess, __pyx_v_namespace); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_6getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, int __pyx_v_size_guess, PyObject *__pyx_v_namespace) { Py_ssize_t __pyx_v_ret; char *__pyx_v_buf; char *__pyx_v_cpath; char *__pyx_v_cname; size_t __pyx_v_bufsize; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; char *__pyx_t_5; PyObject *__pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("getxattr", 0); /* "src/llfuse/fuse_api.pxi":143 * ''' * * if not isinstance(path, str_t): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyObject_IsInstance(__pyx_v_path, __pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 143; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":144 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":146 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str_t): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_name, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 146; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_2) { /* "src/llfuse/fuse_api.pxi":147 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":149 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_1 = __pyx_v_namespace; __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { } else { __pyx_t_2 = __pyx_t_3; goto __pyx_L6_bool_binop_done; } __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_t_1, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 149; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __pyx_t_3; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":151 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef ssize_t ret */ __pyx_t_1 = PyUnicode_Format(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 151; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); /* "src/llfuse/fuse_api.pxi":150 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 150; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":166 * cnamespace = xattr.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * cpath = path_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 166; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_path_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":167 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_1 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 167; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_v_name_b = __pyx_t_1; __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":168 * path_b = str2bytes(path) * name_b = str2bytes(name) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_path_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cpath = ((char *)__pyx_t_5); /* "src/llfuse/fuse_api.pxi":169 * name_b = str2bytes(name) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * bufsize = size_guess */ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_name_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_cname = ((char *)__pyx_t_5); /* "src/llfuse/fuse_api.pxi":171 * cname = name_b * * bufsize = size_guess # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * */ __pyx_v_bufsize = __pyx_v_size_guess; /* "src/llfuse/fuse_api.pxi":172 * * bufsize = size_guess * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * * if buf is NULL: */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "src/llfuse/fuse_api.pxi":174 * buf = stdlib.malloc(bufsize * sizeof(char)) * * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_3 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":175 * * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L8; } __pyx_L8:; /* "src/llfuse/fuse_api.pxi":177 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * with nogil: * IF TARGET_PLATFORM == 'freebsd': */ /*try:*/ { /* "src/llfuse/fuse_api.pxi":178 * * try: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":186 * errno.errno = errno.ERANGE * ELSE: * ret = xattr.getxattr(cpath, cname, buf, bufsize) # <<<<<<<<<<<<<< * * if ret < 0 and errno.errno == errno.ERANGE: */ __pyx_v_ret = getxattr(__pyx_v_cpath, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize); } /* "src/llfuse/fuse_api.pxi":178 * * try: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L14; } __pyx_L14:; } } /* "src/llfuse/fuse_api.pxi":188 * ret = xattr.getxattr(cpath, cname, buf, bufsize) * * if ret < 0 and errno.errno == errno.ERANGE: # <<<<<<<<<<<<<< * with nogil: * IF TARGET_PLATFORM == 'freebsd': */ __pyx_t_2 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_2) { } else { __pyx_t_3 = __pyx_t_2; goto __pyx_L16_bool_binop_done; } __pyx_t_2 = ((errno == ERANGE) != 0); __pyx_t_3 = __pyx_t_2; __pyx_L16_bool_binop_done:; if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":189 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":194 * NULL, 0) * ELSE: * ret = xattr.getxattr(cpath, cname, NULL, 0) # <<<<<<<<<<<<<< * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) */ __pyx_v_ret = getxattr(__pyx_v_cpath, __pyx_v_cname, NULL, 0); } /* "src/llfuse/fuse_api.pxi":189 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L20; } __pyx_L20:; } } /* "src/llfuse/fuse_api.pxi":195 * ELSE: * ret = xattr.getxattr(cpath, cname, NULL, 0) * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret */ __pyx_t_3 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":196 * ret = xattr.getxattr(cpath, cname, NULL, 0) * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * bufsize = ret * stdlib.free(buf) */ __pyx_t_1 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } if (!__pyx_t_9) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __Pyx_GIVEREF(__pyx_t_9); __pyx_t_9 = NULL; PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 196; __pyx_clineno = __LINE__; goto __pyx_L10_error;} } /* "src/llfuse/fuse_api.pxi":197 * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret # <<<<<<<<<<<<<< * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) */ __pyx_v_bufsize = ((size_t)__pyx_v_ret); /* "src/llfuse/fuse_api.pxi":198 * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret * stdlib.free(buf) # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: */ free(__pyx_v_buf); /* "src/llfuse/fuse_api.pxi":199 * bufsize = ret * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * if buf is NULL: * cpython.exc.PyErr_NoMemory() */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "src/llfuse/fuse_api.pxi":200 * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_3 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":201 * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 201; __pyx_clineno = __LINE__; goto __pyx_L10_error;} goto __pyx_L22; } __pyx_L22:; /* "src/llfuse/fuse_api.pxi":203 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":208 * buf, bufsize) * ELSE: * ret = xattr.getxattr(cpath, cname, buf, bufsize) # <<<<<<<<<<<<<< * * if ret < 0: */ __pyx_v_ret = getxattr(__pyx_v_cpath, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize); } /* "src/llfuse/fuse_api.pxi":203 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * IF TARGET_PLATFORM == 'freebsd': * ret = xattr.extattr_get_file(cpath, cnamespace, cname, */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L25; } __pyx_L25:; } } goto __pyx_L15; } __pyx_L15:; /* "src/llfuse/fuse_api.pxi":210 * ret = xattr.getxattr(cpath, cname, buf, bufsize) * * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_3 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":211 * * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * return PyBytes_FromStringAndSize(buf, ret) */ __pyx_t_4 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_10 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_10); __pyx_t_8 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_8) { __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_7); } else { __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_8); __pyx_t_8 = NULL; PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_10); __Pyx_GIVEREF(__pyx_t_10); __pyx_t_10 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __Pyx_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); __pyx_t_4 = 0; __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 211; __pyx_clineno = __LINE__; goto __pyx_L10_error;} } /* "src/llfuse/fuse_api.pxi":213 * raise OSError(errno.errno, strerror(errno.errno), path) * * return PyBytes_FromStringAndSize(buf, ret) # <<<<<<<<<<<<<< * * finally: */ __Pyx_XDECREF(__pyx_r); __pyx_t_7 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_ret); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 213; __pyx_clineno = __LINE__; goto __pyx_L10_error;} __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L9_return; } /* "src/llfuse/fuse_api.pxi":216 * * finally: * stdlib.free(buf) # <<<<<<<<<<<<<< * * def init(ops, mountpoint, list args): */ /*finally:*/ { /*exception exit:*/{ __pyx_L10_error:; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_11 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { free(__pyx_v_buf); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L1_error; } __pyx_L9_return: { __pyx_t_19 = __pyx_r; __pyx_r = 0; free(__pyx_v_buf); __pyx_r = __pyx_t_19; __pyx_t_19 = 0; goto __pyx_L0; } } /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("llfuse.capi.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_9init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_8init[] = "init(ops, mountpoint, list args)\nInitialize and mount FUSE file system\n\n *ops* has to be an instance of the `Operations` class (or another\n class defining the same methods).\n\n *args* has to be a list of strings. Valid options are listed under ``struct\n fuse_opt fuse_mount_opts[]``\n (`mount.c:82 `_)\n and ``struct fuse_opt fuse_ll_opts[]``\n (`fuse_lowlevel_c:2209 `_).\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_9init = {"init", (PyCFunction)__pyx_pw_6llfuse_4capi_9init, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_8init}; static PyObject *__pyx_pw_6llfuse_4capi_9init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_ops = 0; PyObject *__pyx_v_mountpoint = 0; PyObject *__pyx_v_args = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ops,&__pyx_n_s_mountpoint,&__pyx_n_s_args,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ops)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mountpoint)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } case 2: if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, 2); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "init") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_ops = values[0]; __pyx_v_mountpoint = values[1]; __pyx_v_args = ((PyObject*)values[2]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("init", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_args), (&PyList_Type), 1, "args", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_8init(__pyx_self, __pyx_v_ops, __pyx_v_mountpoint, __pyx_v_args); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_8init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_args) { struct fuse_args __pyx_v_f_args; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; char *__pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("init", 0); /* "src/llfuse/fuse_api.pxi":231 * ''' * * log.debug('Initializing llfuse') # <<<<<<<<<<<<<< * cdef fuse_args f_args * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":234 * cdef fuse_args f_args * * if not isinstance(mountpoint, str_t): # <<<<<<<<<<<<<< * raise TypeError('*mountpoint_* argument must be of type str') * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_str_t); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyObject_IsInstance(__pyx_v_mountpoint, __pyx_t_1); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_4 = ((!(__pyx_t_3 != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":235 * * if not isinstance(mountpoint, str_t): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":243 * global channel * * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) # <<<<<<<<<<<<<< * operations = ops * */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_os); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_path); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_abspath); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_5) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_mountpoint); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; __Pyx_INCREF(__pyx_v_mountpoint); PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_mountpoint); __Pyx_GIVEREF(__pyx_v_mountpoint); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_f_6llfuse_4capi_str2bytes(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 243; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_mountpoint_b, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":244 * * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) * operations = ops # <<<<<<<<<<<<<< * * # Initialize Python thread support */ __Pyx_INCREF(__pyx_v_ops); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_operations); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_operations, __pyx_v_ops); __Pyx_GIVEREF(__pyx_v_ops); /* "src/llfuse/fuse_api.pxi":247 * * # Initialize Python thread support * PyEval_InitThreads() # <<<<<<<<<<<<<< * * make_fuse_args(args, &f_args) */ PyEval_InitThreads(); /* "src/llfuse/fuse_api.pxi":249 * PyEval_InitThreads() * * make_fuse_args(args, &f_args) # <<<<<<<<<<<<<< * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) */ __pyx_t_2 = __pyx_f_6llfuse_4capi_make_fuse_args(__pyx_v_args, (&__pyx_v_f_args)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 249; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":250 * * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') # <<<<<<<<<<<<<< * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":251 * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) # <<<<<<<<<<<<<< * if not channel: * raise RuntimeError('fuse_mount failed') */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 251; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_v_6llfuse_4capi_channel = fuse_mount(((char *)__pyx_t_7), (&__pyx_v_f_args)); /* "src/llfuse/fuse_api.pxi":252 * log.debug('Calling fuse_mount') * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: # <<<<<<<<<<<<<< * raise RuntimeError('fuse_mount failed') * */ __pyx_t_4 = ((!(__pyx_v_6llfuse_4capi_channel != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":253 * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: * raise RuntimeError('fuse_mount failed') # <<<<<<<<<<<<<< * * log.debug('Calling fuse_lowlevel_new') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":255 * raise RuntimeError('fuse_mount failed') * * log.debug('Calling fuse_lowlevel_new') # <<<<<<<<<<<<<< * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":256 * * log.debug('Calling fuse_lowlevel_new') * init_fuse_ops() # <<<<<<<<<<<<<< * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: */ __pyx_f_6llfuse_4capi_init_fuse_ops(); /* "src/llfuse/fuse_api.pxi":257 * log.debug('Calling fuse_lowlevel_new') * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) # <<<<<<<<<<<<<< * if not session: * fuse_unmount(mountpoint_b, channel) */ __pyx_v_6llfuse_4capi_session = fuse_lowlevel_new((&__pyx_v_f_args), (&__pyx_v_6llfuse_4capi_fuse_ops), (sizeof(__pyx_v_6llfuse_4capi_fuse_ops)), NULL); /* "src/llfuse/fuse_api.pxi":258 * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") */ __pyx_t_4 = ((!(__pyx_v_6llfuse_4capi_session != 0)) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":259 * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * raise RuntimeError("fuse_lowlevel_new() failed") * */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_7), __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":260 * if not session: * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_set_signal_handlers') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":262 * raise RuntimeError("fuse_lowlevel_new() failed") * * log.debug('Calling fuse_set_signal_handlers') # <<<<<<<<<<<<<< * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":263 * * log.debug('Calling fuse_set_signal_handlers') * if fuse_set_signal_handlers(session) == -1: # <<<<<<<<<<<<<< * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) */ __pyx_t_4 = ((fuse_set_signal_handlers(__pyx_v_6llfuse_4capi_session) == -1) != 0); if (__pyx_t_4) { /* "src/llfuse/fuse_api.pxi":264 * log.debug('Calling fuse_set_signal_handlers') * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") */ fuse_session_destroy(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":265 * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * raise RuntimeError("fuse_set_signal_handlers() failed") * */ __pyx_t_7 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_7), __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":266 * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_add_chan') */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":268 * raise RuntimeError("fuse_set_signal_handlers() failed") * * log.debug('Calling fuse_session_add_chan') # <<<<<<<<<<<<<< * fuse_session_add_chan(session, channel) * */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":269 * * log.debug('Calling fuse_session_add_chan') * fuse_session_add_chan(session, channel) # <<<<<<<<<<<<<< * * def main(single=False): */ fuse_session_add_chan(__pyx_v_6llfuse_4capi_session, __pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_11main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_10main[] = "main(single=False)\nRun FUSE main loop\n\n If *single* is True, all requests will be handled sequentially by\n the thread that has called `main`. If *single* is False, multiple\n worker threads will be started and work on requests concurrently.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_11main = {"main", (PyCFunction)__pyx_pw_6llfuse_4capi_11main, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_10main}; static PyObject *__pyx_pw_6llfuse_4capi_11main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_single = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("main (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_single,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_single); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "main") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_single = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("main", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_10main(__pyx_self, __pyx_v_single); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_10main(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_single) { int __pyx_v_ret; PyObject *__pyx_v_t = NULL; PyObject *__pyx_v_tmp = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("main", 0); /* "src/llfuse/fuse_api.pxi":282 * global exc_info * * if session == NULL: # <<<<<<<<<<<<<< * raise RuntimeError('Need to call init() before main()') * */ __pyx_t_1 = ((__pyx_v_6llfuse_4capi_session == NULL) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":283 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * # Start notification handling thread */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /* "src/llfuse/fuse_api.pxi":286 * * # Start notification handling thread * t = threading.Thread(target=_notify_loop) # <<<<<<<<<<<<<< * t.daemon = True * t.start() */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_threading); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Thread); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_loop); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_target, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 286; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_t = __pyx_t_4; __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":287 * # Start notification handling thread * t = threading.Thread(target=_notify_loop) * t.daemon = True # <<<<<<<<<<<<<< * t.start() * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_daemon, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 287; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":288 * t = threading.Thread(target=_notify_loop) * t.daemon = True * t.start() # <<<<<<<<<<<<<< * * exc_info = None */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_start); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (__pyx_t_3) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else { __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 288; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":290 * t.start() * * exc_info = None # <<<<<<<<<<<<<< * * if single: */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":292 * exc_info = None * * if single: # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_loop') * with nogil: */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_single); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 292; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":293 * * if single: * log.debug('Calling fuse_session_loop') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop(session) */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/llfuse/fuse_api.pxi":294 * if single: * log.debug('Calling fuse_session_loop') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":295 * log.debug('Calling fuse_session_loop') * with nogil: * ret = fuse_session_loop(session) # <<<<<<<<<<<<<< * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: */ __pyx_v_ret = fuse_session_loop(__pyx_v_6llfuse_4capi_session); } /* "src/llfuse/fuse_api.pxi":294 * if single: * log.debug('Calling fuse_session_loop') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L7; } __pyx_L7:; } } /* "src/llfuse/fuse_api.pxi":296 * with nogil: * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop failed") */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_put); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_block, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_timeout, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__66, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/fuse_api.pxi":297 * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_loop failed") * else: */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":298 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop failed") # <<<<<<<<<<<<<< * else: * log.debug('Calling fuse_session_loop_mt') */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } goto __pyx_L4; } /*else*/ { /* "src/llfuse/fuse_api.pxi":300 * raise RuntimeError("fuse_session_loop failed") * else: * log.debug('Calling fuse_session_loop_mt') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop_mt(session) */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/llfuse/fuse_api.pxi":301 * else: * log.debug('Calling fuse_session_loop_mt') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS #endif /*try:*/ { /* "src/llfuse/fuse_api.pxi":302 * log.debug('Calling fuse_session_loop_mt') * with nogil: * ret = fuse_session_loop_mt(session) # <<<<<<<<<<<<<< * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: */ __pyx_v_ret = fuse_session_loop_mt(__pyx_v_6llfuse_4capi_session); } /* "src/llfuse/fuse_api.pxi":301 * else: * log.debug('Calling fuse_session_loop_mt') * with nogil: # <<<<<<<<<<<<<< * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD Py_BLOCK_THREADS #endif goto __pyx_L11; } __pyx_L11:; } } /* "src/llfuse/fuse_api.pxi":303 * with nogil: * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") */ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_put); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_block, Py_True) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_timeout, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__69, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":304 * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_loop_mt() failed") * */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":305 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") # <<<<<<<<<<<<<< * * if exc_info: */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } __pyx_L4:; /* "src/llfuse/fuse_api.pxi":307 * raise RuntimeError("fuse_session_loop_mt() failed") * * if exc_info: # <<<<<<<<<<<<<< * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 307; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":309 * if exc_info: * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":310 * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') * tmp = exc_info # <<<<<<<<<<<<<< * exc_info = None * */ __Pyx_INCREF(__pyx_v_6llfuse_4capi_exc_info); __pyx_v_tmp = __pyx_v_6llfuse_4capi_exc_info; /* "src/llfuse/fuse_api.pxi":311 * log.debug('Terminated main loop because request handler raised exception, re-raising..') * tmp = exc_info * exc_info = None # <<<<<<<<<<<<<< * * # The explicit version check works around a Cython bug with */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":316 * # the 3-parameter version of the raise statement, c.f. * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise tmp[0], tmp[1], tmp[2] * else: */ __pyx_t_1 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_1) { /* "src/llfuse/fuse_api.pxi":317 * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: * raise tmp[0], tmp[1], tmp[2] # <<<<<<<<<<<<<< * else: * raise tmp[1].with_traceback(tmp[2]) */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_4); __Pyx_Raise(__pyx_t_2, __pyx_t_3, __pyx_t_4, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 317; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/fuse_api.pxi":319 * raise tmp[0], tmp[1], tmp[2] * else: * raise tmp[1].with_traceback(tmp[2]) # <<<<<<<<<<<<<< * * def close(unmount=True): */ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_with_traceback); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } if (!__pyx_t_5) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_4); } else { __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 319; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("llfuse.capi.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_t); __Pyx_XDECREF(__pyx_v_tmp); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_13close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_12close[] = "close(unmount=True)\nUnmount file system and clean up\n\n If *unmount* is False, only clean up operations are peformed, but\n the file system is not unmounted. As long as the file system\n process is still running, all requests will hang. Once the process\n has terminated, these (and all future) requests fail with ESHUTDOWN.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_13close = {"close", (PyCFunction)__pyx_pw_6llfuse_4capi_13close, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_12close}; static PyObject *__pyx_pw_6llfuse_4capi_13close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_unmount = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_unmount,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_True); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_unmount); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "close") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_unmount = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("close", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_12close(__pyx_self, __pyx_v_unmount); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_12close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount) { PyObject *__pyx_v_tmp = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close", 0); /* "src/llfuse/fuse_api.pxi":335 * global exc_info * * log.debug('Calling fuse_session_remove_chan') # <<<<<<<<<<<<<< * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":336 * * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) # <<<<<<<<<<<<<< * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) */ fuse_session_remove_chan(__pyx_v_6llfuse_4capi_channel); /* "src/llfuse/fuse_api.pxi":337 * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') # <<<<<<<<<<<<<< * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":338 * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_destroy') * fuse_session_destroy(session) */ fuse_remove_signal_handlers(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":339 * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') # <<<<<<<<<<<<<< * fuse_session_destroy(session) * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":340 * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') * fuse_session_destroy(session) # <<<<<<<<<<<<<< * * if unmount: */ fuse_session_destroy(__pyx_v_6llfuse_4capi_session); /* "src/llfuse/fuse_api.pxi":342 * fuse_session_destroy(session) * * if unmount: # <<<<<<<<<<<<<< * log.debug('Calling fuse_unmount') * fuse_unmount(mountpoint_b, channel) */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_unmount); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 342; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":343 * * if unmount: * log.debug('Calling fuse_unmount') # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * else: */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_log); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":344 * if unmount: * log.debug('Calling fuse_unmount') * fuse_unmount(mountpoint_b, channel) # <<<<<<<<<<<<<< * else: * fuse_chan_destroy(channel) */ __pyx_t_4 = __Pyx_PyObject_AsString(__pyx_v_6llfuse_4capi_mountpoint_b); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 344; __pyx_clineno = __LINE__; goto __pyx_L1_error;} fuse_unmount(((char *)__pyx_t_4), __pyx_v_6llfuse_4capi_channel); goto __pyx_L3; } /*else*/ { /* "src/llfuse/fuse_api.pxi":346 * fuse_unmount(mountpoint_b, channel) * else: * fuse_chan_destroy(channel) # <<<<<<<<<<<<<< * * mountpoint_b = None */ fuse_chan_destroy(__pyx_v_6llfuse_4capi_channel); } __pyx_L3:; /* "src/llfuse/fuse_api.pxi":348 * fuse_chan_destroy(channel) * * mountpoint_b = None # <<<<<<<<<<<<<< * session = NULL * channel = NULL */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_mountpoint_b, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":349 * * mountpoint_b = None * session = NULL # <<<<<<<<<<<<<< * channel = NULL * */ __pyx_v_6llfuse_4capi_session = NULL; /* "src/llfuse/fuse_api.pxi":350 * mountpoint_b = None * session = NULL * channel = NULL # <<<<<<<<<<<<<< * * # destroy handler may have given us an exception */ __pyx_v_6llfuse_4capi_channel = NULL; /* "src/llfuse/fuse_api.pxi":353 * * # destroy handler may have given us an exception * if exc_info: # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_6llfuse_4capi_exc_info); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 353; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":354 * # destroy handler may have given us an exception * if exc_info: * tmp = exc_info # <<<<<<<<<<<<<< * exc_info = None * */ __Pyx_INCREF(__pyx_v_6llfuse_4capi_exc_info); __pyx_v_tmp = __pyx_v_6llfuse_4capi_exc_info; /* "src/llfuse/fuse_api.pxi":355 * if exc_info: * tmp = exc_info * exc_info = None # <<<<<<<<<<<<<< * * # The explicit version check works around a Cython bug with */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_6llfuse_4capi_exc_info); __Pyx_DECREF_SET(__pyx_v_6llfuse_4capi_exc_info, Py_None); __Pyx_GIVEREF(Py_None); /* "src/llfuse/fuse_api.pxi":360 * # the 3-parameter version of the raise statement, c.f. * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * raise tmp[0], tmp[1], tmp[2] * else: */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "src/llfuse/fuse_api.pxi":361 * # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 * if PY_MAJOR_VERSION < 3: * raise tmp[0], tmp[1], tmp[2] # <<<<<<<<<<<<<< * else: * raise tmp[1].with_traceback(tmp[2]) */ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_tmp, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_5); __Pyx_Raise(__pyx_t_1, __pyx_t_2, __pyx_t_5, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 361; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } /*else*/ { /* "src/llfuse/fuse_api.pxi":363 * raise tmp[0], tmp[1], tmp[2] * else: * raise tmp[1].with_traceback(tmp[2]) # <<<<<<<<<<<<<< * * def invalidate_inode(int inode, attr_only=False): */ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_with_traceback); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_tmp, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } if (!__pyx_t_6) { __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_5); } else { __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; {__pyx_filename = __pyx_f[2]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("llfuse.capi.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_tmp); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_15invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_14invalidate_inode[] = "invalidate_inode(int inode, attr_only=False)\nInvalidate cache for *inode*\n\n Instructs the FUSE kernel module to forgot cached attributes and\n data (unless *attr_only* is True) for *inode*. This operation is\n carried out asynchronously, i.e. the method may return before the\n kernel has executed the request.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_15invalidate_inode = {"invalidate_inode", (PyCFunction)__pyx_pw_6llfuse_4capi_15invalidate_inode, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_14invalidate_inode}; static PyObject *__pyx_pw_6llfuse_4capi_15invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_inode; PyObject *__pyx_v_attr_only = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_inode (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode,&__pyx_n_s_attr_only,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inode)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (kw_args > 0) { PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_attr_only); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_inode") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_inode = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_inode == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_attr_only = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_inode", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_6llfuse_4capi_14invalidate_inode(__pyx_self, __pyx_v_inode, __pyx_v_attr_only); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_14invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode, PyObject *__pyx_v_attr_only) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_inode", 0); /* "src/llfuse/fuse_api.pxi":374 * ''' * * _notify_queue.put(inval_inode_req(inode, attr_only)) # <<<<<<<<<<<<<< * * def invalidate_entry(int inode_p, bytes name): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_inode_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_inode); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_attr_only); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_attr_only); __Pyx_GIVEREF(__pyx_v_attr_only); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 374; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_17invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_6llfuse_4capi_16invalidate_entry[] = "invalidate_entry(int inode_p, bytes name)\nInvalidate directory entry\n\n Instructs the FUSE kernel module to forget about the directory\n entry *name* in the directory with inode *inode_p*. This operation\n is carried out asynchronously, i.e. the method may return before\n the kernel has executed the request.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_17invalidate_entry = {"invalidate_entry", (PyCFunction)__pyx_pw_6llfuse_4capi_17invalidate_entry, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_16invalidate_entry}; static PyObject *__pyx_pw_6llfuse_4capi_17invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_inode_p; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_entry (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode_p,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_inode_p)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; case 1: if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("invalidate_entry", 1, 2, 2, 1); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_entry") < 0)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_inode_p = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_inode_p == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_v_name = ((PyObject*)values[1]); } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_entry", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L3_error;} __pyx_L3_error:; __Pyx_AddTraceback("llfuse.capi.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_r = __pyx_pf_6llfuse_4capi_16invalidate_entry(__pyx_self, __pyx_v_inode_p, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_16invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_inode_p, PyObject *__pyx_v_name) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; Py_ssize_t __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_entry", 0); /* "src/llfuse/fuse_api.pxi":385 * ''' * * _notify_queue.put(inval_entry_req(inode_p, name)) # <<<<<<<<<<<<<< * * def get_ino_t_bits(): */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_notify_queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_inval_entry_req); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_inode_p); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_7 = 1; } } __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = NULL; } PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } if (!__pyx_t_4) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(__pyx_t_1); } else { __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_4); __pyx_t_4 = NULL; PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 385; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("llfuse.capi.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_19get_ino_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_18get_ino_t_bits[] = "get_ino_t_bits()\nReturn number of bits available for inode numbers\n\n Attempts to use inode values that need more bytes will result in\n `OverflowError`.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_19get_ino_t_bits = {"get_ino_t_bits", (PyCFunction)__pyx_pw_6llfuse_4capi_19get_ino_t_bits, METH_NOARGS, __pyx_doc_6llfuse_4capi_18get_ino_t_bits}; static PyObject *__pyx_pw_6llfuse_4capi_19get_ino_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_ino_t_bits (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_18get_ino_t_bits(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_18get_ino_t_bits(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations size_t __pyx_t_1; size_t __pyx_t_2; size_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_ino_t_bits", 0); /* "src/llfuse/fuse_api.pxi":393 * `OverflowError`. * ''' * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 # <<<<<<<<<<<<<< * * def get_off_t_bits(): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = (sizeof(fuse_ino_t)); __pyx_t_2 = (sizeof(ino_t)); if (((__pyx_t_1 < __pyx_t_2) != 0)) { __pyx_t_3 = __pyx_t_1; } else { __pyx_t_3 = __pyx_t_2; } __pyx_t_4 = __Pyx_PyInt_FromSize_t((__pyx_t_3 * 8)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 393; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("llfuse.capi.get_ino_t_bits", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ /* Python wrapper */ static PyObject *__pyx_pw_6llfuse_4capi_21get_off_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_6llfuse_4capi_20get_off_t_bits[] = "get_off_t_bits()\nReturn number of bytes available for file offsets\n\n Attempts to use values whose representation needs more bytes will\n result in `OverflowError`.\n "; static PyMethodDef __pyx_mdef_6llfuse_4capi_21get_off_t_bits = {"get_off_t_bits", (PyCFunction)__pyx_pw_6llfuse_4capi_21get_off_t_bits, METH_NOARGS, __pyx_doc_6llfuse_4capi_20get_off_t_bits}; static PyObject *__pyx_pw_6llfuse_4capi_21get_off_t_bits(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_off_t_bits (wrapper)", 0); __pyx_r = __pyx_pf_6llfuse_4capi_20get_off_t_bits(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_6llfuse_4capi_20get_off_t_bits(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_off_t_bits", 0); /* "src/llfuse/fuse_api.pxi":401 * result in `OverflowError`. * ''' * return sizeof(off_t) * 8 # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_FromSize_t(((sizeof(off_t)) * 8)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 401; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("llfuse.capi.get_off_t_bits", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_tp_new_6llfuse_4capi_Lock(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; return o; } static void __pyx_tp_dealloc_6llfuse_4capi_Lock(PyObject *o) { #if PY_VERSION_HEX >= 0x030400a1 if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif (*Py_TYPE(o)->tp_free)(o); } static PyMethodDef __pyx_methods_6llfuse_4capi_Lock[] = { {"acquire", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_3acquire, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_2acquire}, {"release", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_5release, METH_NOARGS, __pyx_doc_6llfuse_4capi_4Lock_4release}, {"yield_", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_7yield_, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_6yield_}, {"__enter__", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_9__enter__, METH_NOARGS, __pyx_doc_6llfuse_4capi_4Lock_8__enter__}, {"__exit__", (PyCFunction)__pyx_pw_6llfuse_4capi_4Lock_11__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_4Lock_10__exit__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6llfuse_4capi_Lock = { PyVarObject_HEAD_INIT(0, 0) "llfuse.capi.Lock", /*tp_name*/ sizeof(struct __pyx_obj_6llfuse_4capi_Lock), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6llfuse_4capi_Lock, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "Lock()\n\n This is the class of lock itself as well as a context manager to\n execute code while the global lock is being held.\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6llfuse_4capi_Lock, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_6llfuse_4capi_4Lock_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6llfuse_4capi_Lock, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyObject *__pyx_tp_new_6llfuse_4capi_NoLockManager(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; return o; } static void __pyx_tp_dealloc_6llfuse_4capi_NoLockManager(PyObject *o) { #if PY_VERSION_HEX >= 0x030400a1 if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif (*Py_TYPE(o)->tp_free)(o); } static PyMethodDef __pyx_methods_6llfuse_4capi_NoLockManager[] = { {"__enter__", (PyCFunction)__pyx_pw_6llfuse_4capi_13NoLockManager_3__enter__, METH_NOARGS, __pyx_doc_6llfuse_4capi_13NoLockManager_2__enter__}, {"__exit__", (PyCFunction)__pyx_pw_6llfuse_4capi_13NoLockManager_5__exit__, METH_VARARGS|METH_KEYWORDS, __pyx_doc_6llfuse_4capi_13NoLockManager_4__exit__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_6llfuse_4capi_NoLockManager = { PyVarObject_HEAD_INIT(0, 0) "llfuse.capi.NoLockManager", /*tp_name*/ sizeof(struct __pyx_obj_6llfuse_4capi_NoLockManager), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_6llfuse_4capi_NoLockManager, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #else 0, /*reserved*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "NoLockManager()\nContext manager to execute code while the global lock is released", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_6llfuse_4capi_NoLockManager, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_6llfuse_4capi_13NoLockManager_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_6llfuse_4capi_NoLockManager, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { #if PY_VERSION_HEX < 0x03020000 { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, #else PyModuleDef_HEAD_INIT, #endif "capi", __pyx_k_capi_pxy_Copyright_2013_Nikolau, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_BaseException, __pyx_k_BaseException, sizeof(__pyx_k_BaseException), 0, 0, 1, 1}, {&__pyx_kp_u_Calling_fuse_lowlevel_new, __pyx_k_Calling_fuse_lowlevel_new, sizeof(__pyx_k_Calling_fuse_lowlevel_new), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_mount, __pyx_k_Calling_fuse_mount, sizeof(__pyx_k_Calling_fuse_mount), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_remove_signal_handl, __pyx_k_Calling_fuse_remove_signal_handl, sizeof(__pyx_k_Calling_fuse_remove_signal_handl), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_add_chan, __pyx_k_Calling_fuse_session_add_chan, sizeof(__pyx_k_Calling_fuse_session_add_chan), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_destroy, __pyx_k_Calling_fuse_session_destroy, sizeof(__pyx_k_Calling_fuse_session_destroy), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_loop, __pyx_k_Calling_fuse_session_loop, sizeof(__pyx_k_Calling_fuse_session_loop), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_loop_mt, __pyx_k_Calling_fuse_session_loop_mt, sizeof(__pyx_k_Calling_fuse_session_loop_mt), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_remove_chan, __pyx_k_Calling_fuse_session_remove_chan, sizeof(__pyx_k_Calling_fuse_session_remove_chan), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_set_signal_handlers, __pyx_k_Calling_fuse_set_signal_handlers, sizeof(__pyx_k_Calling_fuse_set_signal_handlers), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_unmount, __pyx_k_Calling_fuse_unmount, sizeof(__pyx_k_Calling_fuse_unmount), 0, 1, 0, 0}, {&__pyx_n_s_ENOATTR, __pyx_k_ENOATTR, sizeof(__pyx_k_ENOATTR), 0, 0, 1, 1}, {&__pyx_n_s_EntryAttributes, __pyx_k_EntryAttributes, sizeof(__pyx_k_EntryAttributes), 0, 0, 1, 1}, {&__pyx_kp_u_Exception_after_kill, __pyx_k_Exception_after_kill, sizeof(__pyx_k_Exception_after_kill), 0, 1, 0, 0}, {&__pyx_n_s_FUSEError, __pyx_k_FUSEError, sizeof(__pyx_k_FUSEError), 0, 0, 1, 1}, {&__pyx_kp_u_Global_lock_cannot_be_acquired_m, __pyx_k_Global_lock_cannot_be_acquired_m, sizeof(__pyx_k_Global_lock_cannot_be_acquired_m), 0, 1, 0, 0}, {&__pyx_kp_u_Initializing_llfuse, __pyx_k_Initializing_llfuse, sizeof(__pyx_k_Initializing_llfuse), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_can_only_be_released_by_the, __pyx_k_Lock_can_only_be_released_by_the, sizeof(__pyx_k_Lock_can_only_be_released_by_the), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_not_initialized, __pyx_k_Lock_not_initialized, sizeof(__pyx_k_Lock_not_initialized), 0, 1, 0, 0}, {&__pyx_kp_u_Lock_still_taken_after_receiving, __pyx_k_Lock_still_taken_after_receiving, sizeof(__pyx_k_Lock_still_taken_after_receiving), 0, 1, 0, 0}, {&__pyx_kp_u_Need_to_call_init_before_main, __pyx_k_Need_to_call_init_before_main, sizeof(__pyx_k_Need_to_call_init_before_main), 0, 1, 0, 0}, {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1}, {&__pyx_n_s_Operations, __pyx_k_Operations, sizeof(__pyx_k_Operations), 0, 0, 1, 1}, {&__pyx_kp_u_Other_thread_didn_t_take_lock, __pyx_k_Other_thread_didn_t_take_lock, sizeof(__pyx_k_Other_thread_didn_t_take_lock), 0, 1, 0, 0}, {&__pyx_kp_b_Python_LLFUSE, __pyx_k_Python_LLFUSE, sizeof(__pyx_k_Python_LLFUSE), 0, 0, 0, 0}, {&__pyx_n_s_Queue, __pyx_k_Queue, sizeof(__pyx_k_Queue), 0, 0, 1, 1}, {&__pyx_n_s_ROOT_INODE, __pyx_k_ROOT_INODE, sizeof(__pyx_k_ROOT_INODE), 0, 0, 1, 1}, {&__pyx_n_s_RequestContext, __pyx_k_RequestContext, sizeof(__pyx_k_RequestContext), 0, 0, 1, 1}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_kp_u_Terminated_main_loop_because_req, __pyx_k_Terminated_main_loop_because_req, sizeof(__pyx_k_Terminated_main_loop_because_req), 0, 1, 0, 0}, {&__pyx_n_s_Thread, __pyx_k_Thread, sizeof(__pyx_k_Thread), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_kp_u_Weird_request_received_r, __pyx_k_Weird_request_received_r, sizeof(__pyx_k_Weird_request_received_r), 0, 1, 0, 0}, {&__pyx_kp_u_You_should_not_instantiate_this, __pyx_k_You_should_not_instantiate_this, sizeof(__pyx_k_You_should_not_instantiate_this), 0, 1, 0, 0}, {&__pyx_kp_b__28, __pyx_k__28, sizeof(__pyx_k__28), 0, 0, 0, 0}, {&__pyx_n_s_abspath, __pyx_k_abspath, sizeof(__pyx_k_abspath), 0, 0, 1, 1}, {&__pyx_n_s_access, __pyx_k_access, sizeof(__pyx_k_access), 0, 0, 1, 1}, {&__pyx_n_s_acquire, __pyx_k_acquire, sizeof(__pyx_k_acquire), 0, 0, 1, 1}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_attr_only, __pyx_k_attr_only, sizeof(__pyx_k_attr_only), 0, 0, 1, 1}, {&__pyx_n_u_attr_only, __pyx_k_attr_only, sizeof(__pyx_k_attr_only), 0, 1, 0, 1}, {&__pyx_n_s_attr_timeout, __pyx_k_attr_timeout, sizeof(__pyx_k_attr_timeout), 0, 0, 1, 1}, {&__pyx_n_s_block, __pyx_k_block, sizeof(__pyx_k_block), 0, 0, 1, 1}, {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1}, {&__pyx_n_s_bufsize, __pyx_k_bufsize, sizeof(__pyx_k_bufsize), 0, 0, 1, 1}, {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, {&__pyx_n_s_cname, __pyx_k_cname, sizeof(__pyx_k_cname), 0, 0, 1, 1}, {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1}, {&__pyx_n_s_count, __pyx_k_count, sizeof(__pyx_k_count), 0, 0, 1, 1}, {&__pyx_n_s_cpath, __pyx_k_cpath, sizeof(__pyx_k_cpath), 0, 0, 1, 1}, {&__pyx_n_s_create, __pyx_k_create, sizeof(__pyx_k_create), 0, 0, 1, 1}, {&__pyx_n_s_cvalue, __pyx_k_cvalue, sizeof(__pyx_k_cvalue), 0, 0, 1, 1}, {&__pyx_n_s_daemon, __pyx_k_daemon, sizeof(__pyx_k_daemon), 0, 0, 1, 1}, {&__pyx_n_s_debug, __pyx_k_debug, sizeof(__pyx_k_debug), 0, 0, 1, 1}, {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, {&__pyx_n_s_destroy, __pyx_k_destroy, sizeof(__pyx_k_destroy), 0, 0, 1, 1}, {&__pyx_n_s_dirp, __pyx_k_dirp, sizeof(__pyx_k_dirp), 0, 0, 1, 1}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_ent, __pyx_k_ent, sizeof(__pyx_k_ent), 0, 0, 1, 1}, {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, {&__pyx_n_s_entry_timeout, __pyx_k_entry_timeout, sizeof(__pyx_k_entry_timeout), 0, 0, 1, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_errno, __pyx_k_errno, sizeof(__pyx_k_errno), 0, 0, 1, 1}, {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_exc_info, __pyx_k_exc_info, sizeof(__pyx_k_exc_info), 0, 0, 1, 1}, {&__pyx_n_s_exc_tb, __pyx_k_exc_tb, sizeof(__pyx_k_exc_tb), 0, 0, 1, 1}, {&__pyx_n_s_exc_type, __pyx_k_exc_type, sizeof(__pyx_k_exc_type), 0, 0, 1, 1}, {&__pyx_n_s_exc_val, __pyx_k_exc_val, sizeof(__pyx_k_exc_val), 0, 0, 1, 1}, {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, {&__pyx_n_s_f_args, __pyx_k_f_args, sizeof(__pyx_k_f_args), 0, 0, 1, 1}, {&__pyx_n_s_f_bavail, __pyx_k_f_bavail, sizeof(__pyx_k_f_bavail), 0, 0, 1, 1}, {&__pyx_n_s_f_bfree, __pyx_k_f_bfree, sizeof(__pyx_k_f_bfree), 0, 0, 1, 1}, {&__pyx_n_s_f_blocks, __pyx_k_f_blocks, sizeof(__pyx_k_f_blocks), 0, 0, 1, 1}, {&__pyx_n_s_f_bsize, __pyx_k_f_bsize, sizeof(__pyx_k_f_bsize), 0, 0, 1, 1}, {&__pyx_n_s_f_favail, __pyx_k_f_favail, sizeof(__pyx_k_f_favail), 0, 0, 1, 1}, {&__pyx_n_s_f_ffree, __pyx_k_f_ffree, sizeof(__pyx_k_f_ffree), 0, 0, 1, 1}, {&__pyx_n_s_f_files, __pyx_k_f_files, sizeof(__pyx_k_f_files), 0, 0, 1, 1}, {&__pyx_n_s_f_frsize, __pyx_k_f_frsize, sizeof(__pyx_k_f_frsize), 0, 0, 1, 1}, {&__pyx_n_s_flush, __pyx_k_flush, sizeof(__pyx_k_flush), 0, 0, 1, 1}, {&__pyx_n_s_forget, __pyx_k_forget, sizeof(__pyx_k_forget), 0, 0, 1, 1}, {&__pyx_n_s_fse, __pyx_k_fse, sizeof(__pyx_k_fse), 0, 0, 1, 1}, {&__pyx_n_s_fsync, __pyx_k_fsync, sizeof(__pyx_k_fsync), 0, 0, 1, 1}, {&__pyx_n_s_fsyncdir, __pyx_k_fsyncdir, sizeof(__pyx_k_fsyncdir), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_access_fuse_reply__failed_w, __pyx_k_fuse_access_fuse_reply__failed_w, sizeof(__pyx_k_fuse_access_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_create_fuse_reply__failed_w, __pyx_k_fuse_create_fuse_reply__failed_w, sizeof(__pyx_k_fuse_create_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_flush_fuse_reply__failed_wi, __pyx_k_fuse_flush_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_flush_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi, __pyx_k_fuse_fsync_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_fsync_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed, __pyx_k_fuse_fsyncdir_fuse_reply__failed, sizeof(__pyx_k_fuse_fsyncdir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_getattr_fuse_reply__failed, __pyx_k_fuse_getattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_getxattr_fuse_reply__failed, __pyx_k_fuse_getxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_k_fuse_link_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_link_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_listxattr_fuse_reply__faile, __pyx_k_fuse_listxattr_fuse_reply__faile, sizeof(__pyx_k_fuse_listxattr_fuse_reply__faile), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lookup_fuse_reply__failed_w, __pyx_k_fuse_lookup_fuse_reply__failed_w, sizeof(__pyx_k_fuse_lookup_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lowlevel_new_failed, __pyx_k_fuse_lowlevel_new_failed, sizeof(__pyx_k_fuse_lowlevel_new_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi, __pyx_k_fuse_mkdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mkdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi, __pyx_k_fuse_mknod_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mknod_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_mount_failed, __pyx_k_fuse_mount_failed, sizeof(__pyx_k_fuse_mount_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_opendir_fuse_reply__failed, __pyx_k_fuse_opendir_fuse_reply__failed, sizeof(__pyx_k_fuse_opendir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_options_must_be_of_type_str, __pyx_k_fuse_options_must_be_of_type_str, sizeof(__pyx_k_fuse_options_must_be_of_type_str), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_read_fuse_reply__failed_wit, __pyx_k_fuse_read_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_read_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_readdir_fuse_reply__failed, __pyx_k_fuse_readdir_fuse_reply__failed, sizeof(__pyx_k_fuse_readdir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_readlink_fuse_reply__failed, __pyx_k_fuse_readlink_fuse_reply__failed, sizeof(__pyx_k_fuse_readlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_release_fuse_reply__failed, __pyx_k_fuse_release_fuse_reply__failed, sizeof(__pyx_k_fuse_release_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_releasedir_fuse_reply__fail, __pyx_k_fuse_releasedir_fuse_reply__fail, sizeof(__pyx_k_fuse_releasedir_fuse_reply__fail), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_removexattr_fuse_reply__fai, __pyx_k_fuse_removexattr_fuse_reply__fai, sizeof(__pyx_k_fuse_removexattr_fuse_reply__fai), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_rename_fuse_reply__failed_w, __pyx_k_fuse_rename_fuse_reply__failed_w, sizeof(__pyx_k_fuse_rename_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi, __pyx_k_fuse_rmdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_rmdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_loop_failed, __pyx_k_fuse_session_loop_failed, sizeof(__pyx_k_fuse_session_loop_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_loop_mt_failed, __pyx_k_fuse_session_loop_mt_failed, sizeof(__pyx_k_fuse_session_loop_mt_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_set_signal_handlers_failed, __pyx_k_fuse_set_signal_handlers_failed, sizeof(__pyx_k_fuse_set_signal_handlers_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK, __pyx_k_fuse_setattr_clock_gettime_CLOCK, sizeof(__pyx_k_fuse_setattr_clock_gettime_CLOCK), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setattr_fuse_reply__failed, __pyx_k_fuse_setattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setxattr_fuse_reply__failed, __pyx_k_fuse_setxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_statfs_fuse_reply__failed_w, __pyx_k_fuse_statfs_fuse_reply__failed_w, sizeof(__pyx_k_fuse_statfs_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_symlink_fuse_reply__failed, __pyx_k_fuse_symlink_fuse_reply__failed, sizeof(__pyx_k_fuse_symlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_unlink_fuse_reply__failed_w, __pyx_k_fuse_unlink_fuse_reply__failed_w, sizeof(__pyx_k_fuse_unlink_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_err_d_fail, __pyx_k_fuse_write_fuse_reply_err_d_fail, sizeof(__pyx_k_fuse_write_fuse_reply_err_d_fail), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_err_failed, __pyx_k_fuse_write_fuse_reply_err_failed, sizeof(__pyx_k_fuse_write_fuse_reply_err_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply_write_fail, __pyx_k_fuse_write_fuse_reply_write_fail, sizeof(__pyx_k_fuse_write_fuse_reply_write_fail), 0, 1, 0, 0}, {&__pyx_n_s_generation, __pyx_k_generation, sizeof(__pyx_k_generation), 0, 0, 1, 1}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_getLogger, __pyx_k_getLogger, sizeof(__pyx_k_getLogger), 0, 0, 1, 1}, {&__pyx_n_s_get_ino_t_bits, __pyx_k_get_ino_t_bits, sizeof(__pyx_k_get_ino_t_bits), 0, 0, 1, 1}, {&__pyx_n_s_get_off_t_bits, __pyx_k_get_off_t_bits, sizeof(__pyx_k_get_off_t_bits), 0, 0, 1, 1}, {&__pyx_n_s_getattr, __pyx_k_getattr, sizeof(__pyx_k_getattr), 0, 0, 1, 1}, {&__pyx_n_s_getfilesystemencoding, __pyx_k_getfilesystemencoding, sizeof(__pyx_k_getfilesystemencoding), 0, 0, 1, 1}, {&__pyx_n_s_getxattr, __pyx_k_getxattr, sizeof(__pyx_k_getxattr), 0, 0, 1, 1}, {&__pyx_n_s_gid, __pyx_k_gid, sizeof(__pyx_k_gid), 0, 0, 1, 1}, {&__pyx_kp_u_handler_raised_exception_sending, __pyx_k_handler_raised_exception_sending, sizeof(__pyx_k_handler_raised_exception_sending), 0, 1, 0, 0}, {&__pyx_kp_s_home_nikratio_in_progress_pytho, __pyx_k_home_nikratio_in_progress_pytho, sizeof(__pyx_k_home_nikratio_in_progress_pytho), 0, 0, 1, 0}, {&__pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_k_home_nikratio_in_progress_pytho_2, sizeof(__pyx_k_home_nikratio_in_progress_pytho_2), 0, 0, 1, 0}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, {&__pyx_n_s_ino, __pyx_k_ino, sizeof(__pyx_k_ino), 0, 0, 1, 1}, {&__pyx_n_s_inode, __pyx_k_inode, sizeof(__pyx_k_inode), 0, 0, 1, 1}, {&__pyx_n_u_inode, __pyx_k_inode, sizeof(__pyx_k_inode), 0, 1, 0, 1}, {&__pyx_n_s_inode_p, __pyx_k_inode_p, sizeof(__pyx_k_inode_p), 0, 0, 1, 1}, {&__pyx_n_u_inode_p, __pyx_k_inode_p, sizeof(__pyx_k_inode_p), 0, 1, 0, 1}, {&__pyx_n_s_inval_entry_req, __pyx_k_inval_entry_req, sizeof(__pyx_k_inval_entry_req), 0, 0, 1, 1}, {&__pyx_n_u_inval_entry_req, __pyx_k_inval_entry_req, sizeof(__pyx_k_inval_entry_req), 0, 1, 0, 1}, {&__pyx_n_s_inval_inode_req, __pyx_k_inval_inode_req, sizeof(__pyx_k_inval_inode_req), 0, 0, 1, 1}, {&__pyx_n_u_inval_inode_req, __pyx_k_inval_inode_req, sizeof(__pyx_k_inval_inode_req), 0, 1, 0, 1}, {&__pyx_n_s_invalidate_entry, __pyx_k_invalidate_entry, sizeof(__pyx_k_invalidate_entry), 0, 0, 1, 1}, {&__pyx_n_s_invalidate_inode, __pyx_k_invalidate_inode, sizeof(__pyx_k_invalidate_inode), 0, 0, 1, 1}, {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, {&__pyx_n_s_link, __pyx_k_link, sizeof(__pyx_k_link), 0, 0, 1, 1}, {&__pyx_n_s_listdir, __pyx_k_listdir, sizeof(__pyx_k_listdir), 0, 0, 1, 1}, {&__pyx_n_s_listxattr, __pyx_k_listxattr, sizeof(__pyx_k_listxattr), 0, 0, 1, 1}, {&__pyx_n_u_llfuse, __pyx_k_llfuse, sizeof(__pyx_k_llfuse), 0, 1, 0, 1}, {&__pyx_n_s_llfuse_capi, __pyx_k_llfuse_capi, sizeof(__pyx_k_llfuse_capi), 0, 0, 1, 1}, {&__pyx_n_s_llfuse_pyapi, __pyx_k_llfuse_pyapi, sizeof(__pyx_k_llfuse_pyapi), 0, 0, 1, 1}, {&__pyx_n_s_lock, __pyx_k_lock, sizeof(__pyx_k_lock), 0, 0, 1, 1}, {&__pyx_n_s_lock_released, __pyx_k_lock_released, sizeof(__pyx_k_lock_released), 0, 0, 1, 1}, {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1}, {&__pyx_n_s_logging, __pyx_k_logging, sizeof(__pyx_k_logging), 0, 0, 1, 1}, {&__pyx_n_s_lookup, __pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_main_2, __pyx_k_main_2, sizeof(__pyx_k_main_2), 0, 0, 1, 1}, {&__pyx_n_s_maxsize, __pyx_k_maxsize, sizeof(__pyx_k_maxsize), 0, 0, 1, 1}, {&__pyx_n_s_mkdir, __pyx_k_mkdir, sizeof(__pyx_k_mkdir), 0, 0, 1, 1}, {&__pyx_n_s_mknod, __pyx_k_mknod, sizeof(__pyx_k_mknod), 0, 0, 1, 1}, {&__pyx_n_s_mountpoint, __pyx_k_mountpoint, sizeof(__pyx_k_mountpoint), 0, 0, 1, 1}, {&__pyx_kp_u_mountpoint__argument_must_be_of, __pyx_k_mountpoint__argument_must_be_of, sizeof(__pyx_k_mountpoint__argument_must_be_of), 0, 1, 0, 0}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, {&__pyx_kp_u_name_argument_must_be_of_type_s, __pyx_k_name_argument_must_be_of_type_s, sizeof(__pyx_k_name_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_name_b, __pyx_k_name_b, sizeof(__pyx_k_name_b), 0, 0, 1, 1}, {&__pyx_n_s_namedtuple, __pyx_k_namedtuple, sizeof(__pyx_k_namedtuple), 0, 0, 1, 1}, {&__pyx_n_s_names, __pyx_k_names, sizeof(__pyx_k_names), 0, 0, 1, 1}, {&__pyx_n_s_namespace, __pyx_k_namespace, sizeof(__pyx_k_namespace), 0, 0, 1, 1}, {&__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_k_namespace_parameter_must_be_sys, sizeof(__pyx_k_namespace_parameter_must_be_sys), 0, 1, 0, 0}, {&__pyx_n_s_notify_loop, __pyx_k_notify_loop, sizeof(__pyx_k_notify_loop), 0, 0, 1, 1}, {&__pyx_n_s_notify_queue, __pyx_k_notify_queue, sizeof(__pyx_k_notify_queue), 0, 0, 1, 1}, {&__pyx_kp_b_o, __pyx_k_o, sizeof(__pyx_k_o), 0, 0, 0, 0}, {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, {&__pyx_n_s_opendir, __pyx_k_opendir, sizeof(__pyx_k_opendir), 0, 0, 1, 1}, {&__pyx_n_s_ops, __pyx_k_ops, sizeof(__pyx_k_ops), 0, 0, 1, 1}, {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, {&__pyx_n_s_os_path, __pyx_k_os_path, sizeof(__pyx_k_os_path), 0, 0, 1, 1}, {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, {&__pyx_kp_u_path_argument_must_be_of_type_s, __pyx_k_path_argument_must_be_of_type_s, sizeof(__pyx_k_path_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_path_b, __pyx_k_path_b, sizeof(__pyx_k_path_b), 0, 0, 1, 1}, {&__pyx_n_s_pid, __pyx_k_pid, sizeof(__pyx_k_pid), 0, 0, 1, 1}, {&__pyx_n_s_put, __pyx_k_put, sizeof(__pyx_k_put), 0, 0, 1, 1}, {&__pyx_n_s_queue, __pyx_k_queue, sizeof(__pyx_k_queue), 0, 0, 1, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1}, {&__pyx_n_s_readdir, __pyx_k_readdir, sizeof(__pyx_k_readdir), 0, 0, 1, 1}, {&__pyx_n_s_readlink, __pyx_k_readlink, sizeof(__pyx_k_readlink), 0, 0, 1, 1}, {&__pyx_n_s_release, __pyx_k_release, sizeof(__pyx_k_release), 0, 0, 1, 1}, {&__pyx_n_s_releasedir, __pyx_k_releasedir, sizeof(__pyx_k_releasedir), 0, 0, 1, 1}, {&__pyx_n_s_removexattr, __pyx_k_removexattr, sizeof(__pyx_k_removexattr), 0, 0, 1, 1}, {&__pyx_n_s_rename, __pyx_k_rename, sizeof(__pyx_k_rename), 0, 0, 1, 1}, {&__pyx_n_s_req, __pyx_k_req, sizeof(__pyx_k_req), 0, 0, 1, 1}, {&__pyx_n_s_res, __pyx_k_res, sizeof(__pyx_k_res), 0, 0, 1, 1}, {&__pyx_n_s_ret, __pyx_k_ret, sizeof(__pyx_k_ret), 0, 0, 1, 1}, {&__pyx_n_s_rmdir, __pyx_k_rmdir, sizeof(__pyx_k_rmdir), 0, 0, 1, 1}, {&__pyx_n_s_setattr, __pyx_k_setattr, sizeof(__pyx_k_setattr), 0, 0, 1, 1}, {&__pyx_n_s_setxattr, __pyx_k_setxattr, sizeof(__pyx_k_setxattr), 0, 0, 1, 1}, {&__pyx_n_s_single, __pyx_k_single, sizeof(__pyx_k_single), 0, 0, 1, 1}, {&__pyx_n_s_size_guess, __pyx_k_size_guess, sizeof(__pyx_k_size_guess), 0, 0, 1, 1}, {&__pyx_n_s_st_atime, __pyx_k_st_atime, sizeof(__pyx_k_st_atime), 0, 0, 1, 1}, {&__pyx_n_s_st_atime_ns, __pyx_k_st_atime_ns, sizeof(__pyx_k_st_atime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_blksize, __pyx_k_st_blksize, sizeof(__pyx_k_st_blksize), 0, 0, 1, 1}, {&__pyx_n_s_st_blocks, __pyx_k_st_blocks, sizeof(__pyx_k_st_blocks), 0, 0, 1, 1}, {&__pyx_n_s_st_ctime, __pyx_k_st_ctime, sizeof(__pyx_k_st_ctime), 0, 0, 1, 1}, {&__pyx_n_s_st_ctime_ns, __pyx_k_st_ctime_ns, sizeof(__pyx_k_st_ctime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_gid, __pyx_k_st_gid, sizeof(__pyx_k_st_gid), 0, 0, 1, 1}, {&__pyx_n_s_st_ino, __pyx_k_st_ino, sizeof(__pyx_k_st_ino), 0, 0, 1, 1}, {&__pyx_n_s_st_mode, __pyx_k_st_mode, sizeof(__pyx_k_st_mode), 0, 0, 1, 1}, {&__pyx_n_s_st_mtime, __pyx_k_st_mtime, sizeof(__pyx_k_st_mtime), 0, 0, 1, 1}, {&__pyx_n_s_st_mtime_ns, __pyx_k_st_mtime_ns, sizeof(__pyx_k_st_mtime_ns), 0, 0, 1, 1}, {&__pyx_n_s_st_nlink, __pyx_k_st_nlink, sizeof(__pyx_k_st_nlink), 0, 0, 1, 1}, {&__pyx_n_s_st_rdev, __pyx_k_st_rdev, sizeof(__pyx_k_st_rdev), 0, 0, 1, 1}, {&__pyx_n_s_st_size, __pyx_k_st_size, sizeof(__pyx_k_st_size), 0, 0, 1, 1}, {&__pyx_n_s_st_uid, __pyx_k_st_uid, sizeof(__pyx_k_st_uid), 0, 0, 1, 1}, {&__pyx_n_s_stacktrace, __pyx_k_stacktrace, sizeof(__pyx_k_stacktrace), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_statfs, __pyx_k_statfs, sizeof(__pyx_k_statfs), 0, 0, 1, 1}, {&__pyx_n_s_str_t, __pyx_k_str_t, sizeof(__pyx_k_str_t), 0, 0, 1, 1}, {&__pyx_n_s_strerror, __pyx_k_strerror, sizeof(__pyx_k_strerror), 0, 0, 1, 1}, {&__pyx_n_u_surrogateescape, __pyx_k_surrogateescape, sizeof(__pyx_k_surrogateescape), 0, 1, 0, 1}, {&__pyx_n_s_symlink, __pyx_k_symlink, sizeof(__pyx_k_symlink), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_u_system, __pyx_k_system, sizeof(__pyx_k_system), 0, 1, 0, 1}, {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, {&__pyx_n_s_timeout, __pyx_k_timeout, sizeof(__pyx_k_timeout), 0, 0, 1, 1}, {&__pyx_n_s_tmp, __pyx_k_tmp, sizeof(__pyx_k_tmp), 0, 0, 1, 1}, {&__pyx_n_s_uid, __pyx_k_uid, sizeof(__pyx_k_uid), 0, 0, 1, 1}, {&__pyx_n_s_umask, __pyx_k_umask, sizeof(__pyx_k_umask), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_flag_s_o, __pyx_k_unknown_flag_s_o, sizeof(__pyx_k_unknown_flag_s_o), 0, 1, 0, 0}, {&__pyx_n_s_unlink, __pyx_k_unlink, sizeof(__pyx_k_unlink), 0, 0, 1, 1}, {&__pyx_n_s_unmount, __pyx_k_unmount, sizeof(__pyx_k_unmount), 0, 0, 1, 1}, {&__pyx_kp_u_us_ascii, __pyx_k_us_ascii, sizeof(__pyx_k_us_ascii), 0, 1, 0, 0}, {&__pyx_n_u_user, __pyx_k_user, sizeof(__pyx_k_user), 0, 1, 0, 1}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, {&__pyx_n_s_with_traceback, __pyx_k_with_traceback, sizeof(__pyx_k_with_traceback), 0, 0, 1, 1}, {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_BaseException = __Pyx_GetBuiltinName(__pyx_n_s_BaseException); if (!__pyx_builtin_BaseException) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 18; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 169; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 178; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 43; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "src/llfuse/handlers.pxi":16 * cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.init() * except BaseException as e: */ __pyx_tuple_ = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "src/llfuse/handlers.pxi":32 * exc_info = sys.exc_info() * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_Exception_after_kill); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "src/llfuse/handlers.pxi":40 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.lookup(parent, PyBytes_FromString(name)) * fill_entry_param(attr, &entry) */ __pyx_tuple__3 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 40; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "src/llfuse/handlers.pxi":56 * ulong_t nlookup) with gil: * try: * with lock: # <<<<<<<<<<<<<< * operations.forget([(ino, nlookup)]) * except BaseException as e: */ __pyx_tuple__4 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 56; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__4); __Pyx_GIVEREF(__pyx_tuple__4); /* "src/llfuse/handlers.pxi":69 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.getattr(ino) * */ __pyx_tuple__5 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 69; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__5); __Pyx_GIVEREF(__pyx_tuple__5); /* "src/llfuse/handlers.pxi":138 * attr.st_size = None * * with lock: # <<<<<<<<<<<<<< * attr = operations.setattr(ino, attr) * */ __pyx_tuple__6 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 138; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__6); __Pyx_GIVEREF(__pyx_tuple__6); /* "src/llfuse/handlers.pxi":156 * cdef char* name * try: * with lock: # <<<<<<<<<<<<<< * target = operations.readlink(ino) * name = PyBytes_AsString(target) */ __pyx_tuple__7 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 156; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__7); __Pyx_GIVEREF(__pyx_tuple__7); /* "src/llfuse/handlers.pxi":175 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mknod(parent, PyBytes_FromString(name), mode, * rdev, ctx) */ __pyx_tuple__8 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 175; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__8); __Pyx_GIVEREF(__pyx_tuple__8); /* "src/llfuse/handlers.pxi":198 * mode = ((mode & ~S_IFMT) | S_IFDIR) * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) * fill_entry_param(attr, &entry) */ __pyx_tuple__9 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 198; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__9); __Pyx_GIVEREF(__pyx_tuple__9); /* "src/llfuse/handlers.pxi":214 * * try: * with lock: # <<<<<<<<<<<<<< * operations.unlink(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__10 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__10); __Pyx_GIVEREF(__pyx_tuple__10); /* "src/llfuse/handlers.pxi":229 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rmdir(parent, PyBytes_FromString(name)) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__11 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 229; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__11); __Pyx_GIVEREF(__pyx_tuple__11); /* "src/llfuse/handlers.pxi":247 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * attr = operations.symlink(parent, PyBytes_FromString(name), * PyBytes_FromString(link), ctx) */ __pyx_tuple__12 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 247; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__12); __Pyx_GIVEREF(__pyx_tuple__12); /* "src/llfuse/handlers.pxi":265 * * try: * with lock: # <<<<<<<<<<<<<< * operations.rename(parent, PyBytes_FromString(name), * newparent, PyBytes_FromString(newname)) */ __pyx_tuple__13 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__13); __Pyx_GIVEREF(__pyx_tuple__13); /* "src/llfuse/handlers.pxi":283 * * try: * with lock: # <<<<<<<<<<<<<< * attr = operations.link(ino, newparent, PyBytes_FromString(newname)) * fill_entry_param(attr, &entry) */ __pyx_tuple__14 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__14); __Pyx_GIVEREF(__pyx_tuple__14); /* "src/llfuse/handlers.pxi":300 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.open(ino, fi.flags) * */ __pyx_tuple__15 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__15); __Pyx_GIVEREF(__pyx_tuple__15); /* "src/llfuse/handlers.pxi":323 * * try: * with lock: # <<<<<<<<<<<<<< * buf = operations.read(fi.fh, off, size) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_tuple__16 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__16)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__16); __Pyx_GIVEREF(__pyx_tuple__16); /* "src/llfuse/handlers.pxi":345 * try: * pbuf = PyBytes_FromStringAndSize(buf, size) * with lock: # <<<<<<<<<<<<<< * len_ = operations.write(fi.fh, off, pbuf) * ret = fuse_reply_write(req, len_) */ __pyx_tuple__17 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 345; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "src/llfuse/handlers.pxi":364 * * try: * with lock: # <<<<<<<<<<<<<< * operations.flush(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__18 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 364; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__18); __Pyx_GIVEREF(__pyx_tuple__18); /* "src/llfuse/handlers.pxi":379 * * try: * with lock: # <<<<<<<<<<<<<< * operations.release(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__19 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__19); __Pyx_GIVEREF(__pyx_tuple__19); /* "src/llfuse/handlers.pxi":395 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsync(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__20 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__20); __Pyx_GIVEREF(__pyx_tuple__20); /* "src/llfuse/handlers.pxi":410 * * try: * with lock: # <<<<<<<<<<<<<< * fi.fh = operations.opendir(ino) * */ __pyx_tuple__21 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 410; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__21); __Pyx_GIVEREF(__pyx_tuple__21); /* "src/llfuse/handlers.pxi":436 * acc_size = 0 * buf = NULL * with lock: # <<<<<<<<<<<<<< * for (name, attr, next_) in operations.readdir(fi.fh, off): * if buf == NULL: */ __pyx_tuple__22 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 436; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__22); __Pyx_GIVEREF(__pyx_tuple__22); /* "src/llfuse/handlers.pxi":463 * * try: * with lock: # <<<<<<<<<<<<<< * operations.releasedir(fi.fh) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__23 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 463; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__23); __Pyx_GIVEREF(__pyx_tuple__23); /* "src/llfuse/handlers.pxi":480 * * try: * with lock: # <<<<<<<<<<<<<< * operations.fsyncdir(fi.fh, datasync != 0) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__24 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "src/llfuse/handlers.pxi":499 * string.memset(&cstats, 0, sizeof(cstats)) * try: * with lock: # <<<<<<<<<<<<<< * stats = operations.statfs() * */ __pyx_tuple__25 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__25)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "src/llfuse/handlers.pxi":555 * raise ValueError('unknown flag(s): %o' % flags) * * with lock: # <<<<<<<<<<<<<< * if flags & xattr.XATTR_CREATE: # Attribute must not exist * try: */ __pyx_tuple__26 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 555; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__26); __Pyx_GIVEREF(__pyx_tuple__26); /* "src/llfuse/handlers.pxi":599 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * buf = operations.getxattr(ino, name) * PyBytes_AsStringAndSize(buf, &cbuf, &len_) */ __pyx_tuple__27 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 599; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__27); __Pyx_GIVEREF(__pyx_tuple__27); /* "src/llfuse/handlers.pxi":622 * cdef char *cbuf * try: * with lock: # <<<<<<<<<<<<<< * buf = b'\0'.join(operations.listxattr(ino)) + b'\0' * */ __pyx_tuple__29 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__29); __Pyx_GIVEREF(__pyx_tuple__29); /* "src/llfuse/handlers.pxi":648 * try: * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * operations.removexattr(ino, name) * ret = fuse_reply_err(req, 0) */ __pyx_tuple__30 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__30); __Pyx_GIVEREF(__pyx_tuple__30); /* "src/llfuse/handlers.pxi":664 * try: * ctx = get_request_context(req) * with lock: # <<<<<<<<<<<<<< * allowed = operations.access(ino, mask, ctx) * if allowed: */ __pyx_tuple__31 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 664; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__31); __Pyx_GIVEREF(__pyx_tuple__31); /* "src/llfuse/handlers.pxi":687 * ctx = get_request_context(req) * name = PyBytes_FromString(cname) * with lock: # <<<<<<<<<<<<<< * (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) * */ __pyx_tuple__32 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 687; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__32); __Pyx_GIVEREF(__pyx_tuple__32); /* "src/llfuse/misc.pxi":79 * if not exc_info: * exc_info = sys.exc_info() * log.debug('handler raised exception, sending SIGTERM to self.') # <<<<<<<<<<<<<< * kill(getpid(), SIGTERM) * else: */ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_u_handler_raised_exception_sending); if (unlikely(!__pyx_tuple__33)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__33); __Pyx_GIVEREF(__pyx_tuple__33); /* "src/llfuse/misc.pxi":82 * kill(getpid(), SIGTERM) * else: * log.exception('Exception after kill:') # <<<<<<<<<<<<<< * * if req is NULL: */ __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_u_Exception_after_kill); if (unlikely(!__pyx_tuple__34)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__34); __Pyx_GIVEREF(__pyx_tuple__34); /* "src/llfuse/misc.pxi":152 * for el in args: * if not isinstance(el, str_t): * raise TypeError('fuse options must be of type str') # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_u_fuse_options_must_be_of_type_str); if (unlikely(!__pyx_tuple__35)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 152; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__35); __Pyx_GIVEREF(__pyx_tuple__35); /* "src/llfuse/misc.pxi":154 * raise TypeError('fuse options must be of type str') * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) # <<<<<<<<<<<<<< * args = args_new * */ __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_u_us_ascii); if (unlikely(!__pyx_tuple__36)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 154; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__36); __Pyx_GIVEREF(__pyx_tuple__36); /* "src/llfuse/misc.pxi":192 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_u_You_should_not_instantiate_this); if (unlikely(!__pyx_tuple__37)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 192; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__37); __Pyx_GIVEREF(__pyx_tuple__37); /* "src/llfuse/misc.pxi":219 * return False * elif ret == EDEADLK: * raise RuntimeError("Global lock cannot be acquired more than once") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_u_Global_lock_cannot_be_acquired_m); if (unlikely(!__pyx_tuple__38)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 219; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "src/llfuse/misc.pxi":221 * raise RuntimeError("Global lock cannot be acquired more than once") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_u_Lock_still_taken_after_receiving); if (unlikely(!__pyx_tuple__39)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 221; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__39); __Pyx_GIVEREF(__pyx_tuple__39); /* "src/llfuse/misc.pxi":223 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__40)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); /* "src/llfuse/misc.pxi":237 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_u_Lock_can_only_be_released_by_the); if (unlikely(!__pyx_tuple__41)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__41); __Pyx_GIVEREF(__pyx_tuple__41); /* "src/llfuse/misc.pxi":239 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__42)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 239; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__42); __Pyx_GIVEREF(__pyx_tuple__42); /* "src/llfuse/misc.pxi":261 * return * elif ret == EPERM: * raise RuntimeError("Lock can only be released by the holding thread") # <<<<<<<<<<<<<< * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") */ __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_u_Lock_can_only_be_released_by_the); if (unlikely(!__pyx_tuple__43)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 261; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); /* "src/llfuse/misc.pxi":263 * raise RuntimeError("Lock can only be released by the holding thread") * elif ret == EPROTO: * raise RuntimeError("Lock still taken after receiving unlock notification") # <<<<<<<<<<<<<< * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") */ __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_u_Lock_still_taken_after_receiving); if (unlikely(!__pyx_tuple__44)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 263; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__44); __Pyx_GIVEREF(__pyx_tuple__44); /* "src/llfuse/misc.pxi":265 * raise RuntimeError("Lock still taken after receiving unlock notification") * elif ret == ENOMSG: * raise RuntimeError("Other thread didn't take lock") # <<<<<<<<<<<<<< * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") */ __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_u_Other_thread_didn_t_take_lock); if (unlikely(!__pyx_tuple__45)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__45); __Pyx_GIVEREF(__pyx_tuple__45); /* "src/llfuse/misc.pxi":267 * raise RuntimeError("Other thread didn't take lock") * elif ret == EINVAL: * raise RuntimeError("Lock not initialized") # <<<<<<<<<<<<<< * else: * raise RuntimeError(strerror(ret)) */ __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_u_Lock_not_initialized); if (unlikely(!__pyx_tuple__46)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__46); __Pyx_GIVEREF(__pyx_tuple__46); /* "src/llfuse/misc.pxi":282 * * def __init__(self): * raise TypeError('You should not instantiate this class, use the ' # <<<<<<<<<<<<<< * 'provided instance instead.') * */ __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_u_You_should_not_instantiate_this); if (unlikely(!__pyx_tuple__47)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 282; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); /* "src/llfuse/fuse_api.pxi":28 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef dirent.DIR* dirp */ __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__48)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 28; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__48); __Pyx_GIVEREF(__pyx_tuple__48); /* "src/llfuse/fuse_api.pxi":82 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__51)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 82; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); /* "src/llfuse/fuse_api.pxi":85 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_name_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__52)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 85; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__52); __Pyx_GIVEREF(__pyx_tuple__52); /* "src/llfuse/fuse_api.pxi":144 * * if not isinstance(path, str_t): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str_t): */ __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__53)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 144; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); /* "src/llfuse/fuse_api.pxi":147 * * if not isinstance(name, str_t): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_tuple__54 = PyTuple_Pack(1, __pyx_kp_u_name_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__54)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 147; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__54); __Pyx_GIVEREF(__pyx_tuple__54); /* "src/llfuse/fuse_api.pxi":231 * ''' * * log.debug('Initializing llfuse') # <<<<<<<<<<<<<< * cdef fuse_args f_args * */ __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_Initializing_llfuse); if (unlikely(!__pyx_tuple__55)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); /* "src/llfuse/fuse_api.pxi":235 * * if not isinstance(mountpoint, str_t): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_mountpoint__argument_must_be_of); if (unlikely(!__pyx_tuple__56)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); /* "src/llfuse/fuse_api.pxi":250 * * make_fuse_args(args, &f_args) * log.debug('Calling fuse_mount') # <<<<<<<<<<<<<< * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: */ __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_mount); if (unlikely(!__pyx_tuple__57)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 250; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__57); __Pyx_GIVEREF(__pyx_tuple__57); /* "src/llfuse/fuse_api.pxi":253 * channel = fuse_mount(mountpoint_b, &f_args) * if not channel: * raise RuntimeError('fuse_mount failed') # <<<<<<<<<<<<<< * * log.debug('Calling fuse_lowlevel_new') */ __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_u_fuse_mount_failed); if (unlikely(!__pyx_tuple__58)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 253; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__58); __Pyx_GIVEREF(__pyx_tuple__58); /* "src/llfuse/fuse_api.pxi":255 * raise RuntimeError('fuse_mount failed') * * log.debug('Calling fuse_lowlevel_new') # <<<<<<<<<<<<<< * init_fuse_ops() * session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) */ __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_lowlevel_new); if (unlikely(!__pyx_tuple__59)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 255; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); /* "src/llfuse/fuse_api.pxi":260 * if not session: * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_lowlevel_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_set_signal_handlers') */ __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_u_fuse_lowlevel_new_failed); if (unlikely(!__pyx_tuple__60)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 260; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__60); __Pyx_GIVEREF(__pyx_tuple__60); /* "src/llfuse/fuse_api.pxi":262 * raise RuntimeError("fuse_lowlevel_new() failed") * * log.debug('Calling fuse_set_signal_handlers') # <<<<<<<<<<<<<< * if fuse_set_signal_handlers(session) == -1: * fuse_session_destroy(session) */ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_set_signal_handlers); if (unlikely(!__pyx_tuple__61)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 262; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); /* "src/llfuse/fuse_api.pxi":266 * fuse_session_destroy(session) * fuse_unmount(mountpoint_b, channel) * raise RuntimeError("fuse_set_signal_handlers() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_add_chan') */ __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_u_fuse_set_signal_handlers_failed); if (unlikely(!__pyx_tuple__62)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); /* "src/llfuse/fuse_api.pxi":268 * raise RuntimeError("fuse_set_signal_handlers() failed") * * log.debug('Calling fuse_session_add_chan') # <<<<<<<<<<<<<< * fuse_session_add_chan(session, channel) * */ __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_add_chan); if (unlikely(!__pyx_tuple__63)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 268; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); /* "src/llfuse/fuse_api.pxi":283 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * # Start notification handling thread */ __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_u_Need_to_call_init_before_main); if (unlikely(!__pyx_tuple__64)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 283; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); /* "src/llfuse/fuse_api.pxi":293 * * if single: * log.debug('Calling fuse_session_loop') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop(session) */ __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_loop); if (unlikely(!__pyx_tuple__65)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); /* "src/llfuse/fuse_api.pxi":296 * with nogil: * ret = fuse_session_loop(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop failed") */ __pyx_tuple__66 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__66)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__66); __Pyx_GIVEREF(__pyx_tuple__66); /* "src/llfuse/fuse_api.pxi":298 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop failed") # <<<<<<<<<<<<<< * else: * log.debug('Calling fuse_session_loop_mt') */ __pyx_tuple__67 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_loop_failed); if (unlikely(!__pyx_tuple__67)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); /* "src/llfuse/fuse_api.pxi":300 * raise RuntimeError("fuse_session_loop failed") * else: * log.debug('Calling fuse_session_loop_mt') # <<<<<<<<<<<<<< * with nogil: * ret = fuse_session_loop_mt(session) */ __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_loop_mt); if (unlikely(!__pyx_tuple__68)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 300; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__68); __Pyx_GIVEREF(__pyx_tuple__68); /* "src/llfuse/fuse_api.pxi":303 * with nogil: * ret = fuse_session_loop_mt(session) * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread # <<<<<<<<<<<<<< * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") */ __pyx_tuple__69 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__69)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 303; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); /* "src/llfuse/fuse_api.pxi":305 * _notify_queue.put(None, block=True, timeout=5) # Stop notification thread * if ret != 0: * raise RuntimeError("fuse_session_loop_mt() failed") # <<<<<<<<<<<<<< * * if exc_info: */ __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_loop_mt_failed); if (unlikely(!__pyx_tuple__70)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 305; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__70); __Pyx_GIVEREF(__pyx_tuple__70); /* "src/llfuse/fuse_api.pxi":309 * if exc_info: * # Re-raise expression from request handler * log.debug('Terminated main loop because request handler raised exception, re-raising..') # <<<<<<<<<<<<<< * tmp = exc_info * exc_info = None */ __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_u_Terminated_main_loop_because_req); if (unlikely(!__pyx_tuple__71)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 309; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); /* "src/llfuse/fuse_api.pxi":335 * global exc_info * * log.debug('Calling fuse_session_remove_chan') # <<<<<<<<<<<<<< * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') */ __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_remove_chan); if (unlikely(!__pyx_tuple__72)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 335; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__72); __Pyx_GIVEREF(__pyx_tuple__72); /* "src/llfuse/fuse_api.pxi":337 * log.debug('Calling fuse_session_remove_chan') * fuse_session_remove_chan(channel) * log.debug('Calling fuse_remove_signal_handlers') # <<<<<<<<<<<<<< * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') */ __pyx_tuple__73 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_remove_signal_handl); if (unlikely(!__pyx_tuple__73)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__73); __Pyx_GIVEREF(__pyx_tuple__73); /* "src/llfuse/fuse_api.pxi":339 * log.debug('Calling fuse_remove_signal_handlers') * fuse_remove_signal_handlers(session) * log.debug('Calling fuse_session_destroy') # <<<<<<<<<<<<<< * fuse_session_destroy(session) * */ __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_session_destroy); if (unlikely(!__pyx_tuple__74)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__74); __Pyx_GIVEREF(__pyx_tuple__74); /* "src/llfuse/fuse_api.pxi":343 * * if unmount: * log.debug('Calling fuse_unmount') # <<<<<<<<<<<<<< * fuse_unmount(mountpoint_b, channel) * else: */ __pyx_tuple__75 = PyTuple_Pack(1, __pyx_kp_u_Calling_fuse_unmount); if (unlikely(!__pyx_tuple__75)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 343; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__75); __Pyx_GIVEREF(__pyx_tuple__75); /* "llfuse/capi.pyx":93 * ################## * * log = logging.getLogger("llfuse") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __pyx_tuple__76 = PyTuple_Pack(1, __pyx_n_u_llfuse); if (unlikely(!__pyx_tuple__76)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__76); __Pyx_GIVEREF(__pyx_tuple__76); /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ __pyx_tuple__77 = PyTuple_Pack(4, __pyx_n_s_len, __pyx_n_s_ino, __pyx_n_s_cname, __pyx_n_s_req); if (unlikely(!__pyx_tuple__77)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__77); __Pyx_GIVEREF(__pyx_tuple__77); __pyx_codeobj__78 = (PyObject*)__Pyx_PyCode_New(0, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho, __pyx_n_s_notify_loop, 291, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__78)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_tuple__79 = PyTuple_Pack(8, __pyx_n_s_path, __pyx_n_s_dirp, __pyx_n_s_ent, __pyx_n_s_res, __pyx_n_s_ret, __pyx_n_s_buf, __pyx_n_s_path_b, __pyx_n_s_names); if (unlikely(!__pyx_tuple__79)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__79); __Pyx_GIVEREF(__pyx_tuple__79); __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__79, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_listdir, 14, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_tuple__81 = PyTuple_Pack(11, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_len, __pyx_n_s_cvalue, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__81)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__81); __Pyx_GIVEREF(__pyx_tuple__81); __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(4, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_setxattr, 66, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_tuple__83 = PyTuple_Pack(11, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_size_guess, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_buf, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_bufsize, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__83)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__83); __Pyx_GIVEREF(__pyx_tuple__83); __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(4, 0, 11, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__83, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_getxattr, 122, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __pyx_tuple__85 = PyTuple_Pack(4, __pyx_n_s_ops, __pyx_n_s_mountpoint, __pyx_n_s_args, __pyx_n_s_f_args); if (unlikely(!__pyx_tuple__85)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__85); __Pyx_GIVEREF(__pyx_tuple__85); __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__85, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_init, 218, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ __pyx_tuple__87 = PyTuple_Pack(4, __pyx_n_s_single, __pyx_n_s_ret, __pyx_n_s_t, __pyx_n_s_tmp); if (unlikely(!__pyx_tuple__87)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__87); __Pyx_GIVEREF(__pyx_tuple__87); __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__87, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_main_2, 271, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ __pyx_tuple__89 = PyTuple_Pack(2, __pyx_n_s_unmount, __pyx_n_s_tmp); if (unlikely(!__pyx_tuple__89)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__89); __Pyx_GIVEREF(__pyx_tuple__89); __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__89, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_close, 321, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_tuple__91 = PyTuple_Pack(2, __pyx_n_s_inode, __pyx_n_s_attr_only); if (unlikely(!__pyx_tuple__91)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__91); __Pyx_GIVEREF(__pyx_tuple__91); __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__91, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_invalidate_inode, 365, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_tuple__93 = PyTuple_Pack(2, __pyx_n_s_inode_p, __pyx_n_s_name); if (unlikely(!__pyx_tuple__93)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_tuple__93); __Pyx_GIVEREF(__pyx_tuple__93); __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__93, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_invalidate_entry, 376, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_get_ino_t_bits, 387, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_nikratio_in_progress_pytho_2, __pyx_n_s_get_off_t_bits, 395, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; __pyx_float_1e9 = PyFloat_FromDouble(1e9); if (unlikely(!__pyx_float_1e9)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1000 = PyInt_FromLong(1000); if (unlikely(!__pyx_int_1000)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_int_1000000000 = PyInt_FromLong(1000000000L); if (unlikely(!__pyx_int_1000000000)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC initcapi(void); /*proto*/ PyMODINIT_FUNC initcapi(void) #else PyMODINIT_FUNC PyInit_capi(void); /*proto*/ PyMODINIT_FUNC PyInit_capi(void) #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; Py_ssize_t __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_capi(void)", 0); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("capi", __pyx_methods, __pyx_k_capi_pxy_Copyright_2013_Nikolau, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif if (__pyx_module_is_main_llfuse__capi) { if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (!PyDict_GetItemString(modules, "llfuse.capi")) { if (unlikely(PyDict_SetItemString(modules, "llfuse.capi", __pyx_m) < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } #endif /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ __pyx_v_6llfuse_4capi_operations = Py_None; Py_INCREF(Py_None); __pyx_v_6llfuse_4capi_mountpoint_b = Py_None; Py_INCREF(Py_None); __pyx_v_6llfuse_4capi_exc_info = Py_None; Py_INCREF(Py_None); /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ if (PyType_Ready(&__pyx_type_6llfuse_4capi_Lock) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 185; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6llfuse_4capi_Lock.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "Lock", (PyObject *)&__pyx_type_6llfuse_4capi_Lock) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 185; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6llfuse_4capi_Lock = &__pyx_type_6llfuse_4capi_Lock; if (PyType_Ready(&__pyx_type_6llfuse_4capi_NoLockManager) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_type_6llfuse_4capi_NoLockManager.tp_print = 0; if (PyObject_SetAttrString(__pyx_m, "NoLockManager", (PyObject *)&__pyx_type_6llfuse_4capi_NoLockManager) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_ptype_6llfuse_4capi_NoLockManager = &__pyx_type_6llfuse_4capi_NoLockManager; /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "llfuse/capi.pyx":13 * cdef extern from *: * char* LLFUSE_VERSION * __version__ = LLFUSE_VERSION.decode('utf-8') # <<<<<<<<<<<<<< * * */ __pyx_t_1 = __Pyx_decode_c_string(LLFUSE_VERSION, 0, strlen(LLFUSE_VERSION), NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 13; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 13; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":74 * ################ * * import os # <<<<<<<<<<<<<< * import logging * import sys */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 74; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 74; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":75 * * import os * import logging # <<<<<<<<<<<<<< * import sys * import os.path */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_logging, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_logging, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 75; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":76 * import os * import logging * import sys # <<<<<<<<<<<<<< * import os.path * import threading */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 76; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":77 * import logging * import sys * import os.path # <<<<<<<<<<<<<< * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os_path, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 77; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":78 * import sys * import os.path * import threading # <<<<<<<<<<<<<< * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes * from collections import namedtuple */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_threading, 0, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 78; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":79 * import os.path * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes # <<<<<<<<<<<<<< * from collections import namedtuple * */ __pyx_t_1 = PyList_New(5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_FUSEError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_FUSEError); __Pyx_GIVEREF(__pyx_n_s_FUSEError); __Pyx_INCREF(__pyx_n_s_strerror); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_strerror); __Pyx_GIVEREF(__pyx_n_s_strerror); __Pyx_INCREF(__pyx_n_s_Operations); PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_Operations); __Pyx_GIVEREF(__pyx_n_s_Operations); __Pyx_INCREF(__pyx_n_s_RequestContext); PyList_SET_ITEM(__pyx_t_1, 3, __pyx_n_s_RequestContext); __Pyx_GIVEREF(__pyx_n_s_RequestContext); __Pyx_INCREF(__pyx_n_s_EntryAttributes); PyList_SET_ITEM(__pyx_t_1, 4, __pyx_n_s_EntryAttributes); __Pyx_GIVEREF(__pyx_n_s_EntryAttributes); __pyx_t_2 = __Pyx_Import(__pyx_n_s_llfuse_pyapi, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FUSEError); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_FUSEError, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_strerror); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_strerror, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Operations); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Operations, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_RequestContext); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_RequestContext, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_EntryAttributes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_EntryAttributes, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 79; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":80 * import threading * from llfuse.pyapi import FUSEError, strerror, Operations, RequestContext, EntryAttributes * from collections import namedtuple # <<<<<<<<<<<<<< * * if PY_MAJOR_VERSION < 3: */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_namedtuple); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_namedtuple); __Pyx_GIVEREF(__pyx_n_s_namedtuple); __pyx_t_1 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_namedtuple); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_namedtuple, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 80; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":82 * from collections import namedtuple * * if PY_MAJOR_VERSION < 3: # <<<<<<<<<<<<<< * from Queue import Queue * str_t = bytes */ __pyx_t_3 = ((PY_MAJOR_VERSION < 3) != 0); if (__pyx_t_3) { /* "llfuse/capi.pyx":83 * * if PY_MAJOR_VERSION < 3: * from Queue import Queue # <<<<<<<<<<<<<< * str_t = bytes * else: */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Queue); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Queue); __Pyx_GIVEREF(__pyx_n_s_Queue); __pyx_t_2 = __Pyx_Import(__pyx_n_s_Queue, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Queue, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 83; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":84 * if PY_MAJOR_VERSION < 3: * from Queue import Queue * str_t = bytes # <<<<<<<<<<<<<< * else: * from queue import Queue */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_t, ((PyObject *)((PyObject*)(&PyBytes_Type)))) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 84; __pyx_clineno = __LINE__; goto __pyx_L1_error;} goto __pyx_L2; } /*else*/ { /* "llfuse/capi.pyx":86 * str_t = bytes * else: * from queue import Queue # <<<<<<<<<<<<<< * str_t = str * */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_Queue); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Queue); __Pyx_GIVEREF(__pyx_n_s_Queue); __pyx_t_1 = __Pyx_Import(__pyx_n_s_queue, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Queue, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 86; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":87 * else: * from queue import Queue * str_t = str # <<<<<<<<<<<<<< * * ################## */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_str_t, ((PyObject *)((PyObject*)(&PyUnicode_Type)))) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 87; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __pyx_L2:; /* "llfuse/capi.pyx":93 * ################## * * log = logging.getLogger("llfuse") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_logging); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_getLogger); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_log, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 93; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":94 * * log = logging.getLogger("llfuse") * fse = sys.getfilesystemencoding() # <<<<<<<<<<<<<< * * cdef object operations */ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getfilesystemencoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } if (__pyx_t_2) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else { __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_fse, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 94; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":98 * cdef object operations * cdef object mountpoint_b * cdef fuse_session* session = NULL # <<<<<<<<<<<<<< * cdef fuse_chan* channel = NULL * cdef fuse_lowlevel_ops fuse_ops */ __pyx_v_6llfuse_4capi_session = NULL; /* "llfuse/capi.pyx":99 * cdef object mountpoint_b * cdef fuse_session* session = NULL * cdef fuse_chan* channel = NULL # <<<<<<<<<<<<<< * cdef fuse_lowlevel_ops fuse_ops * cdef object exc_info */ __pyx_v_6llfuse_4capi_channel = NULL; /* "llfuse/capi.pyx":103 * cdef object exc_info * * init_lock() # <<<<<<<<<<<<<< * lock = Lock.__new__(Lock) * lock_released = NoLockManager.__new__(NoLockManager) */ init_lock(); /* "llfuse/capi.pyx":104 * * init_lock() * lock = Lock.__new__(Lock) # <<<<<<<<<<<<<< * lock_released = NoLockManager.__new__(NoLockManager) * */ __pyx_t_1 = __pyx_tp_new_6llfuse_4capi_Lock(((PyTypeObject *)((PyObject*)__pyx_ptype_6llfuse_4capi_Lock)), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_lock, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 104; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":105 * init_lock() * lock = Lock.__new__(Lock) * lock_released = NoLockManager.__new__(NoLockManager) # <<<<<<<<<<<<<< * * _notify_queue = Queue(maxsize=1000) */ __pyx_t_1 = __pyx_tp_new_6llfuse_4capi_NoLockManager(((PyTypeObject *)((PyObject*)__pyx_ptype_6llfuse_4capi_NoLockManager)), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_lock_released, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 105; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "llfuse/capi.pyx":107 * lock_released = NoLockManager.__new__(NoLockManager) * * _notify_queue = Queue(maxsize=1000) # <<<<<<<<<<<<<< * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) */ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_Queue); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_maxsize, __pyx_int_1000) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_queue, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 107; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":108 * * _notify_queue = Queue(maxsize=1000) * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) # <<<<<<<<<<<<<< * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) * */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_namedtuple); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_u_inode); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_u_inode); __Pyx_GIVEREF(__pyx_n_u_inode); __Pyx_INCREF(__pyx_n_u_attr_only); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_u_attr_only); __Pyx_GIVEREF(__pyx_n_u_attr_only); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_n_u_inval_inode_req); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_n_u_inval_inode_req); __Pyx_GIVEREF(__pyx_n_u_inval_inode_req); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_inval_inode_req, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 108; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":109 * _notify_queue = Queue(maxsize=1000) * inval_inode_req = namedtuple('inval_inode_req', [ 'inode', 'attr_only' ]) * inval_entry_req = namedtuple('inval_entry_req', [ 'inode_p', 'name' ]) # <<<<<<<<<<<<<< * * # Exported for access from Python code */ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_namedtuple); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_4); __pyx_t_7 = PyList_New(2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_n_u_inode_p); PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_u_inode_p); __Pyx_GIVEREF(__pyx_n_u_inode_p); __Pyx_INCREF(__pyx_n_u_name); PyList_SET_ITEM(__pyx_t_7, 1, __pyx_n_u_name); __Pyx_GIVEREF(__pyx_n_u_name); __pyx_t_1 = NULL; __pyx_t_6 = 0; if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_1) { PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = NULL; } __Pyx_INCREF(__pyx_n_u_inval_entry_req); PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_n_u_inval_entry_req); __Pyx_GIVEREF(__pyx_n_u_inval_entry_req); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_inval_entry_req, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 109; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":112 * * # Exported for access from Python code * ROOT_INODE = FUSE_ROOT_ID # <<<<<<<<<<<<<< * ENOATTR = errno.ENOATTR * */ __pyx_t_2 = __Pyx_PyInt_From_int(FUSE_ROOT_ID); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROOT_INODE, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 112; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":113 * # Exported for access from Python code * ROOT_INODE = FUSE_ROOT_ID * ENOATTR = errno.ENOATTR # <<<<<<<<<<<<<< * * ####################### */ __pyx_t_2 = __Pyx_PyInt_From_int(ENOATTR); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ENOATTR, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/misc.pxi":291 * lock.acquire() * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Read notifications from queue and send to FUSE kernel module''' * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_1_notify_loop, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_loop, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 291; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":14 * ''' * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_3listdir, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_listdir, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 14; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":66 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_5setxattr, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setxattr, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 66; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":122 * * * def getxattr(path, name, int size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_7getxattr, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_getxattr, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 122; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":218 * stdlib.free(buf) * * def init(ops, mountpoint, list args): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_9init, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_init, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":271 * fuse_session_add_chan(session, channel) * * def main(single=False): # <<<<<<<<<<<<<< * '''Run FUSE main loop * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_11main, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_main_2, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 271; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":321 * raise tmp[1].with_traceback(tmp[2]) * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Unmount file system and clean up * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_13close, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_close, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 321; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":365 * raise tmp[1].with_traceback(tmp[2]) * * def invalidate_inode(int inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_15invalidate_inode, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_inode, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 365; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":376 * _notify_queue.put(inval_inode_req(inode, attr_only)) * * def invalidate_entry(int inode_p, bytes name): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_17invalidate_entry, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_entry, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":387 * _notify_queue.put(inval_entry_req(inode_p, name)) * * def get_ino_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bits available for inode numbers * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_19get_ino_t_bits, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_ino_t_bits, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/llfuse/fuse_api.pxi":395 * return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 * * def get_off_t_bits(): # <<<<<<<<<<<<<< * '''Return number of bytes available for file offsets * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_6llfuse_4capi_21get_off_t_bits, NULL, __pyx_n_s_llfuse_capi); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_off_t_bits, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 395; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "llfuse/capi.pyx":1 * ''' # <<<<<<<<<<<<<< * capi.pxy * */ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init llfuse.capi", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init llfuse.capi"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif } /* Runtime support code */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule((char *)modname); if (!m) goto end; p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON result = PyDict_GetItem(__pyx_d, name); if (likely(result)) { Py_INCREF(result); } else { #else result = PyObject_GetItem(__pyx_d, name); if (!result) { PyErr_Clear(); #endif result = __Pyx_GetBuiltinName(name); } return result; } #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject* args = PyTuple_Pack(1, arg); return (likely(args)) ? __Pyx_PyObject_Call(func, args, NULL) : NULL; } #endif #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { #else if (likely(PyCFunction_Check(func))) { #endif if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); #else PyErr_GetExcInfo(type, value, tb); #endif } static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(type, value, tb); #endif } static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) { PyObject *local_type, *local_value, *local_tb; #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_COMPILING_IN_CPYTHON tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { #if CYTHON_COMPILING_IN_CPYTHON PyObject *tmp_type, *tmp_value, *tmp_tb; PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_Restore(type, value, tb); #endif } static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(type, value, tb); #endif } static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } } static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #else PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_COMPILING_IN_CPYTHON PyThreadState *tstate = PyThreadState_GET(); PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { if (PyObject_IsSubclass(instance_class, type)) { type = instance_class; } else { instance_class = NULL; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } #if PY_VERSION_HEX >= 0x03030000 if (cause) { #else if (cause && cause != Py_None) { #endif PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(tmp_type, tmp_value, tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = PyThreadState_GET(); PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif #if !CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); } #endif static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } static CYTHON_INLINE int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); } static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (none_allowed && obj == Py_None) return 1; else if (exact) { if (likely(Py_TYPE(obj) == type)) return 1; #if PY_MAJOR_VERSION == 2 else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(PyObject_TypeCheck(obj, type))) return 1; } __Pyx_RaiseArgumentTypeInvalid(name, obj, type); return 0; } static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck) { #if CYTHON_COMPILING_IN_CPYTHON if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (PyErr_ExceptionMatches(PyExc_OverflowError)) PyErr_Clear(); else return NULL; } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { Py_ssize_t length; if (unlikely((start < 0) | (stop < 0))) { length = strlen(cstring); if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; } length = stop - start; if (unlikely(length <= 0)) return PyUnicode_FromUnicode(NULL, 0); cstring += start; if (decode_func) { return decode_func(cstring, length, errors); } else { return PyUnicode_Decode(cstring, length, encoding, errors); } } static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = (start + end) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; py_code = __pyx_find_code_object(c_line ? c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? c_line : py_line, py_code); } py_frame = PyFrame_New( PyThreadState_GET(), /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; py_frame->f_lineno = py_line; PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_VERSION_HEX < 0x03030000 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if (strchr(__Pyx_MODULE_NAME, '.')) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(1); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); #endif if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_VERSION_HEX < 0x03030000 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_VERSION_HEX < 0x03030000 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(int) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value) \ { \ func_type value = func_value; \ if (sizeof(target_type) < sizeof(func_type)) { \ if (unlikely(value != (func_type) (target_type) value)) { \ func_type zero = 0; \ if (is_unsigned && unlikely(value < zero)) \ goto raise_neg_overflow; \ else \ goto raise_overflow; \ } \ } \ return (target_type) value; \ } #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #endif #endif static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(int) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(int, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyLong_AsLong(x)) } else if (sizeof(int) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(int, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value) { const fuse_ino_t neg_one = (fuse_ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(fuse_ino_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(fuse_ino_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fuse_ino_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(fuse_ino_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) { const unsigned long neg_one = (unsigned long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(unsigned long) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(unsigned long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned long) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(unsigned long), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(long) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value) { const time_t neg_one = (time_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(time_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(time_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(time_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(time_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(time_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(time_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value) { const mode_t neg_one = (mode_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(mode_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(mode_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(mode_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(mode_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(mode_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(mode_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value) { const uid_t neg_one = (uid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uid_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value) { const gid_t neg_one = (gid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(gid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(gid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(gid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(gid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(gid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(gid_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value) { const off_t neg_one = (off_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(off_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(off_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(off_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(off_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(off_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(off_t), little, !is_unsigned); } } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value) { const dev_t neg_one = (dev_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(dev_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(dev_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(dev_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(dev_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(dev_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(dev_t), little, !is_unsigned); } } static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) { const uint64_t neg_one = (uint64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uint64_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint64_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(uint64_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(uint64_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(uint64_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long, PyLong_AsLong(x)) } else if (sizeof(uint64_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uint64_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uint64_t) -1; } } else { uint64_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (uint64_t) -1; val = __Pyx_PyInt_As_uint64_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint64_t"); return (uint64_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint64_t"); return (uint64_t) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) { const uint64_t neg_one = (uint64_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint64_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(uint64_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(uint64_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint64_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uint64_t), little, !is_unsigned); } } static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { const size_t neg_one = (size_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(size_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (size_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(size_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(size_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(size_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyLong_AsLong(x)) } else if (sizeof(size_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(size_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else size_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (size_t) -1; } } else { size_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (size_t) -1; val = __Pyx_PyInt_As_size_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to size_t"); return (size_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to size_t"); return (size_t) -1; } static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *x) { const off_t neg_one = (off_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(off_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(off_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (off_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(off_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(off_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(off_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(off_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(off_t, long, PyLong_AsLong(x)) } else if (sizeof(off_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(off_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else off_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (off_t) -1; } } else { off_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (off_t) -1; val = __Pyx_PyInt_As_off_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to off_t"); return (off_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to off_t"); return (off_t) -1; } static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *x) { const fuse_ino_t neg_one = (fuse_ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fuse_ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fuse_ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fuse_ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, PyLong_AsLong(x)) } else if (sizeof(fuse_ino_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fuse_ino_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fuse_ino_t) -1; } } else { fuse_ino_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fuse_ino_t) -1; val = __Pyx_PyInt_As_fuse_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fuse_ino_t"); return (fuse_ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fuse_ino_t"); return (fuse_ino_t) -1; } static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) { const unsigned long neg_one = (unsigned long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(unsigned long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(unsigned long) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(unsigned long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyLong_AsLong(x)) } else if (sizeof(unsigned long) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned long val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned long) -1; } } else { unsigned long val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (unsigned long) -1; val = __Pyx_PyInt_As_unsigned_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned long"); return (unsigned long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned long"); return (unsigned long) -1; } static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *x) { const ino_t neg_one = (ino_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(ino_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(ino_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(ino_t, long, PyLong_AsLong(x)) } else if (sizeof(ino_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(ino_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else ino_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (ino_t) -1; } } else { ino_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (ino_t) -1; val = __Pyx_PyInt_As_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to ino_t"); return (ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to ino_t"); return (ino_t) -1; } static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *x) { const mode_t neg_one = (mode_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(mode_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(mode_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (mode_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(mode_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(mode_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(mode_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(mode_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(mode_t, long, PyLong_AsLong(x)) } else if (sizeof(mode_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(mode_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else mode_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (mode_t) -1; } } else { mode_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (mode_t) -1; val = __Pyx_PyInt_As_mode_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to mode_t"); return (mode_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to mode_t"); return (mode_t) -1; } static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *x) { const nlink_t neg_one = (nlink_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(nlink_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (nlink_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(nlink_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(nlink_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(nlink_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(nlink_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long, PyLong_AsLong(x)) } else if (sizeof(nlink_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else nlink_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (nlink_t) -1; } } else { nlink_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (nlink_t) -1; val = __Pyx_PyInt_As_nlink_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to nlink_t"); return (nlink_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to nlink_t"); return (nlink_t) -1; } static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *x) { const uid_t neg_one = (uid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(uid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(uid_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(uid_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(uid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(uid_t, long, PyLong_AsLong(x)) } else if (sizeof(uid_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(uid_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uid_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uid_t) -1; } } else { uid_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (uid_t) -1; val = __Pyx_PyInt_As_uid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uid_t"); return (uid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uid_t"); return (uid_t) -1; } static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *x) { const gid_t neg_one = (gid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(gid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(gid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (gid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(gid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(gid_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(gid_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(gid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(gid_t, long, PyLong_AsLong(x)) } else if (sizeof(gid_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(gid_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else gid_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (gid_t) -1; } } else { gid_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (gid_t) -1; val = __Pyx_PyInt_As_gid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to gid_t"); return (gid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to gid_t"); return (gid_t) -1; } static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *x) { const dev_t neg_one = (dev_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(dev_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(dev_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (dev_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(dev_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(dev_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(dev_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(dev_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(dev_t, long, PyLong_AsLong(x)) } else if (sizeof(dev_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(dev_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else dev_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (dev_t) -1; } } else { dev_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (dev_t) -1; val = __Pyx_PyInt_As_dev_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to dev_t"); return (dev_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to dev_t"); return (dev_t) -1; } static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *x) { const blksize_t neg_one = (blksize_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blksize_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blksize_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(blksize_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(blksize_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(blksize_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(blksize_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long, PyLong_AsLong(x)) } else if (sizeof(blksize_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blksize_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blksize_t) -1; } } else { blksize_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (blksize_t) -1; val = __Pyx_PyInt_As_blksize_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blksize_t"); return (blksize_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blksize_t"); return (blksize_t) -1; } static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *x) { const blkcnt_t neg_one = (blkcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(blkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(blkcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(blkcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(blkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(blkcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blkcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blkcnt_t) -1; } } else { blkcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (blkcnt_t) -1; val = __Pyx_PyInt_As_blkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blkcnt_t"); return (blkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blkcnt_t"); return (blkcnt_t) -1; } static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) { const time_t neg_one = (time_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(time_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(time_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (time_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(time_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(time_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(time_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(time_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(time_t, long, PyLong_AsLong(x)) } else if (sizeof(time_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(time_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else time_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (time_t) -1; } } else { time_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (time_t) -1; val = __Pyx_PyInt_As_time_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to time_t"); return (time_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to time_t"); return (time_t) -1; } static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(long) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(long, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyLong_AsLong(x)) } else if (sizeof(long) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(long, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *x) { const fsblkcnt_t neg_one = (fsblkcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsblkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsblkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fsblkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fsblkcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fsblkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(fsblkcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsblkcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsblkcnt_t) -1; } } else { fsblkcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fsblkcnt_t) -1; val = __Pyx_PyInt_As_fsblkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsblkcnt_t"); return (fsblkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsblkcnt_t"); return (fsblkcnt_t) -1; } static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *x) { const fsfilcnt_t neg_one = (fsfilcnt_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsfilcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsfilcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } if (sizeof(fsfilcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) } else if (sizeof(fsfilcnt_t) <= sizeof(unsigned long long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long long, PyLong_AsUnsignedLongLong(x)) } } else { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(x)) { case 0: return 0; case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, +(((PyLongObject*)x)->ob_digit[0])); case -1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, sdigit, -(sdigit) ((PyLongObject*)x)->ob_digit[0]); } #endif #endif if (sizeof(fsfilcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, PyLong_AsLong(x)) } else if (sizeof(fsfilcnt_t) <= sizeof(long long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long long, PyLong_AsLongLong(x)) } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsfilcnt_t val; PyObject *v = __Pyx_PyNumber_Int(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsfilcnt_t) -1; } } else { fsfilcnt_t val; PyObject *tmp = __Pyx_PyNumber_Int(x); if (!tmp) return (fsfilcnt_t) -1; val = __Pyx_PyInt_As_fsfilcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsfilcnt_t"); return (fsfilcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsfilcnt_t"); return (fsfilcnt_t) -1; } static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value) { const pid_t neg_one = (pid_t) -1, const_zero = 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(pid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(pid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); } else if (sizeof(pid_t) <= sizeof(unsigned long long)) { return PyLong_FromUnsignedLongLong((unsigned long long) value); } } else { if (sizeof(pid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(pid_t) <= sizeof(long long)) { return PyLong_FromLongLong((long long) value); } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(pid_t), little, !is_unsigned); } } static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { #if PY_VERSION_HEX < 0x03030000 char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; #else if (__Pyx_PyUnicode_READY(o) == -1) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (PyUnicode_IS_ASCII(o)) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif #endif } else #endif #if !CYTHON_COMPILING_IN_PYPY if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { PyNumberMethods *m; const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (PyInt_Check(x) || PyLong_Check(x)) #else if (PyLong_Check(x)) #endif return Py_INCREF(x), x; m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = PyNumber_Int(x); } else if (m && m->nb_long) { name = "long"; res = PyNumber_Long(x); } #else if (m && m->nb_int) { name = "int"; res = PyNumber_Long(x); } #endif if (res) { #if PY_MAJOR_VERSION < 3 if (!PyInt_Check(res) && !PyLong_Check(res)) { #else if (!PyLong_Check(res)) { #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", name, name, Py_TYPE(res)->tp_name); Py_DECREF(res); return NULL; } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) return PyInt_AS_LONG(b); #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 #if CYTHON_USE_PYLONG_INTERNALS switch (Py_SIZE(b)) { case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0]; case 0: return 0; case 1: return ((PyLongObject*)b)->ob_digit[0]; } #endif #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ llfuse-0.41.1/src/llfuse/fuse_api.pxi0000664000175000017500000003131512557232665021171 0ustar nikrationikratio00000000000000''' fuse_api.pxi This file defines the Python bindings to common FUSE API functions. It is included by llfuse.pyx. Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' def listdir(path): '''Like `os.listdir`, but releases the GIL. This function returns an iterator over the directory entries in *path*. The returned values are of type :ref:`str ` in both Python 2.x and 3.x. In Python 2.x :class:`str` is equivalent to `bytes` so all names can be represented. In Python 3.x, surrogate escape coding (cf. `PEP 383 `_) is used for directory names that do not have a string representation. ''' if not isinstance(path, str_t): raise TypeError('*path* argument must be of type str') cdef dirent.DIR* dirp cdef dirent.dirent ent cdef dirent.dirent* res cdef int ret cdef char* buf path_b = str2bytes(path) buf = path_b with nogil: dirp = dirent.opendir(buf) if dirp == NULL: raise OSError(errno.errno, strerror(errno.errno), path) names = list() while True: errno.errno = 0 with nogil: ret = dirent.readdir_r(dirp, &ent, &res) if ret != 0: raise OSError(errno.errno, strerror(errno.errno), path) if res is NULL: break if string.strcmp(ent.d_name, b'.') == 0 or string.strcmp(ent.d_name, b'..') == 0: continue names.append(bytes2str(PyBytes_FromString(ent.d_name))) with nogil: dirent.closedir(dirp) return names def setxattr(path, name, bytes value, namespace='user'): '''Set extended attribute *path* and *name* have to be of type `str`. In Python 3.x, they may contain surrogates. *value* has to be of type `bytes`. Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to select the namespace for the extended attribute. For other platforms, this parameter is ignored. In contrast the `os.setxattr` function from the standard library, the method provided by Python-LLFUSE is also available for non-Linux systems. ''' if not isinstance(path, str_t): raise TypeError('*path* argument must be of type str') if not isinstance(name, str_t): raise TypeError('*name* argument must be of type str') if namespace not in ('system', 'user'): raise ValueError('*namespace* parameter must be "system" or "user", not %s' % namespace) cdef int ret cdef Py_ssize_t len_ cdef char *cvalue cdef char *cpath cdef char *cname IF TARGET_PLATFORM == 'freebsd': cdef int cnamespace if namespace == 'system': cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM else: cnamespace = xattr.EXTATTR_NAMESPACE_USER path_b = str2bytes(path) name_b = str2bytes(name) PyBytes_AsStringAndSize(value, &cvalue, &len_) cpath = path_b cname = name_b with nogil: IF TARGET_PLATFORM == 'freebsd': ret = xattr.extattr_set_file(cpath, cnamespace, cname, cvalue, len_) ELSE: ret = xattr.setxattr(cpath, cname, cvalue, len_, 0) if ret != 0: raise OSError(errno.errno, strerror(errno.errno), path) def getxattr(path, name, int size_guess=128, namespace='user'): '''Get extended attribute *path* and *name* have to be of type `str`. In Python 3.x, they may contain surrogates. Returns a value of type `bytes`. If the caller knows the approximate size of the attribute value, it should be supplied in *size_guess*. If the guess turns out to be wrong, the system call has to be carried out three times (the first call will fail, the second determines the size and the third finally gets the value). Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to select the namespace for the extended attribute. For other platforms, this parameter is ignored. In contrast the `os.setxattr` function from the standard library, the method provided by Python-LLFUSE is also available for non-Linux systems. ''' if not isinstance(path, str_t): raise TypeError('*path* argument must be of type str') if not isinstance(name, str_t): raise TypeError('*name* argument must be of type str') if namespace not in ('system', 'user'): raise ValueError('*namespace* parameter must be "system" or "user", not %s' % namespace) cdef ssize_t ret cdef char *buf cdef char *cpath cdef char *cname cdef size_t bufsize IF TARGET_PLATFORM == 'freebsd': cdef int cnamespace if namespace == 'system': cnamespace = xattr.EXTATTR_NAMESPACE_SYSTEM else: cnamespace = xattr.EXTATTR_NAMESPACE_USER path_b = str2bytes(path) name_b = str2bytes(name) cpath = path_b cname = name_b bufsize = size_guess buf = stdlib.malloc(bufsize * sizeof(char)) if buf is NULL: cpython.exc.PyErr_NoMemory() try: with nogil: IF TARGET_PLATFORM == 'freebsd': ret = xattr.extattr_get_file(cpath, cnamespace, cname, buf, bufsize) if ret == bufsize: ret = -1 errno.errno = errno.ERANGE ELSE: ret = xattr.getxattr(cpath, cname, buf, bufsize) if ret < 0 and errno.errno == errno.ERANGE: with nogil: IF TARGET_PLATFORM == 'freebsd': ret = xattr.extattr_get_file(cpath, cnamespace, cname, NULL, 0) ELSE: ret = xattr.getxattr(cpath, cname, NULL, 0) if ret < 0: raise OSError(errno.errno, strerror(errno.errno), path) bufsize = ret stdlib.free(buf) buf = stdlib.malloc(bufsize * sizeof(char)) if buf is NULL: cpython.exc.PyErr_NoMemory() with nogil: IF TARGET_PLATFORM == 'freebsd': ret = xattr.extattr_get_file(cpath, cnamespace, cname, buf, bufsize) ELSE: ret = xattr.getxattr(cpath, cname, buf, bufsize) if ret < 0: raise OSError(errno.errno, strerror(errno.errno), path) return PyBytes_FromStringAndSize(buf, ret) finally: stdlib.free(buf) def init(ops, mountpoint, list args): '''Initialize and mount FUSE file system *ops* has to be an instance of the `Operations` class (or another class defining the same methods). *args* has to be a list of strings. Valid options are listed under ``struct fuse_opt fuse_mount_opts[]`` (`mount.c:82 `_) and ``struct fuse_opt fuse_ll_opts[]`` (`fuse_lowlevel_c:2209 `_). ''' log.debug('Initializing llfuse') cdef fuse_args f_args if not isinstance(mountpoint, str_t): raise TypeError('*mountpoint_* argument must be of type str') global operations global fuse_ops global mountpoint_b global session global channel mountpoint_b = str2bytes(os.path.abspath(mountpoint)) operations = ops # Initialize Python thread support PyEval_InitThreads() make_fuse_args(args, &f_args) log.debug('Calling fuse_mount') channel = fuse_mount(mountpoint_b, &f_args) if not channel: raise RuntimeError('fuse_mount failed') log.debug('Calling fuse_lowlevel_new') init_fuse_ops() session = fuse_lowlevel_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) if not session: fuse_unmount(mountpoint_b, channel) raise RuntimeError("fuse_lowlevel_new() failed") log.debug('Calling fuse_set_signal_handlers') if fuse_set_signal_handlers(session) == -1: fuse_session_destroy(session) fuse_unmount(mountpoint_b, channel) raise RuntimeError("fuse_set_signal_handlers() failed") log.debug('Calling fuse_session_add_chan') fuse_session_add_chan(session, channel) def main(single=False): '''Run FUSE main loop If *single* is True, all requests will be handled sequentially by the thread that has called `main`. If *single* is False, multiple worker threads will be started and work on requests concurrently. ''' cdef int ret global exc_info if session == NULL: raise RuntimeError('Need to call init() before main()') # Start notification handling thread t = threading.Thread(target=_notify_loop) t.daemon = True t.start() exc_info = None if single: log.debug('Calling fuse_session_loop') with nogil: ret = fuse_session_loop(session) _notify_queue.put(None, block=True, timeout=5) # Stop notification thread if ret != 0: raise RuntimeError("fuse_session_loop failed") else: log.debug('Calling fuse_session_loop_mt') with nogil: ret = fuse_session_loop_mt(session) _notify_queue.put(None, block=True, timeout=5) # Stop notification thread if ret != 0: raise RuntimeError("fuse_session_loop_mt() failed") if exc_info: # Re-raise expression from request handler log.debug('Terminated main loop because request handler raised exception, re-raising..') tmp = exc_info exc_info = None # The explicit version check works around a Cython bug with # the 3-parameter version of the raise statement, c.f. # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 if PY_MAJOR_VERSION < 3: raise tmp[0], tmp[1], tmp[2] else: raise tmp[1].with_traceback(tmp[2]) def close(unmount=True): '''Unmount file system and clean up If *unmount* is False, only clean up operations are peformed, but the file system is not unmounted. As long as the file system process is still running, all requests will hang. Once the process has terminated, these (and all future) requests fail with ESHUTDOWN. ''' global mountpoint_b global session global channel global exc_info log.debug('Calling fuse_session_remove_chan') fuse_session_remove_chan(channel) log.debug('Calling fuse_remove_signal_handlers') fuse_remove_signal_handlers(session) log.debug('Calling fuse_session_destroy') fuse_session_destroy(session) if unmount: log.debug('Calling fuse_unmount') fuse_unmount(mountpoint_b, channel) else: fuse_chan_destroy(channel) mountpoint_b = None session = NULL channel = NULL # destroy handler may have given us an exception if exc_info: tmp = exc_info exc_info = None # The explicit version check works around a Cython bug with # the 3-parameter version of the raise statement, c.f. # https://github.com/cython/cython/commit/a6195f1a44ab21f5aa4b2a1b1842dd93115a3f42 if PY_MAJOR_VERSION < 3: raise tmp[0], tmp[1], tmp[2] else: raise tmp[1].with_traceback(tmp[2]) def invalidate_inode(int inode, attr_only=False): '''Invalidate cache for *inode* Instructs the FUSE kernel module to forgot cached attributes and data (unless *attr_only* is True) for *inode*. This operation is carried out asynchronously, i.e. the method may return before the kernel has executed the request. ''' _notify_queue.put(inval_inode_req(inode, attr_only)) def invalidate_entry(int inode_p, bytes name): '''Invalidate directory entry Instructs the FUSE kernel module to forget about the directory entry *name* in the directory with inode *inode_p*. This operation is carried out asynchronously, i.e. the method may return before the kernel has executed the request. ''' _notify_queue.put(inval_entry_req(inode_p, name)) def get_ino_t_bits(): '''Return number of bits available for inode numbers Attempts to use inode values that need more bytes will result in `OverflowError`. ''' return min(sizeof(ino_t), sizeof(fuse_ino_t)) * 8 def get_off_t_bits(): '''Return number of bytes available for file offsets Attempts to use values whose representation needs more bytes will result in `OverflowError`. ''' return sizeof(off_t) * 8 llfuse-0.41.1/src/llfuse/handlers.pxi0000664000175000017500000005541112566230152021166 0ustar nikrationikratio00000000000000''' handlers.pxi This file defines the FUSE request handlers. It is included by llfuse.pyx. Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' cdef void fuse_init (void *userdata, fuse_conn_info *conn) with gil: try: with lock: operations.init() except BaseException as e: handle_exc('init', e, NULL) cdef void fuse_destroy (void *userdata) with gil: # Note: called by fuse_session_destroy(), i.e. not as part of the # main loop but only when llfuse.close() is called. # (therefore we don't obtain the global lock) global exc_info try: operations.destroy() except: if not exc_info: exc_info = sys.exc_info() else: log.exception('Exception after kill:') cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: cdef fuse_entry_param entry cdef int ret try: with lock: attr = operations.lookup(parent, PyBytes_FromString(name)) fill_entry_param(attr, &entry) ret = fuse_reply_entry(req, &entry) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('lookup', e, req) if ret != 0: log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, ulong_t nlookup) with gil: try: with lock: operations.forget([(ino, nlookup)]) except BaseException as e: handle_exc('forget', e, NULL) fuse_reply_none(req) cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: cdef c_stat stat cdef int ret cdef int timeout try: with lock: attr = operations.getattr(ino) fill_c_stat(attr, &stat) timeout = attr.attr_timeout ret = fuse_reply_attr(req, &stat, timeout) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('getattr', e, req) if ret != 0: log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, c_stat *stat, int to_set, fuse_file_info *fi) with gil: cdef int ret cdef c_stat stat_n cdef int timeout cdef timespec now try: attr = EntryAttributes() if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): ret = clock_gettime(CLOCK_REALTIME, &now) if ret != 0: log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', strerror(errno.errno)) # Type casting required on 64bit, where double # is smaller than long int. if to_set & FUSE_SET_ATTR_ATIME: attr.st_atime = stat.st_atime + GET_ATIME_NS(stat) * 1e-9 attr.st_atime_ns = stat.st_atime * 10**9 + GET_ATIME_NS(stat) elif to_set & FUSE_SET_ATTR_ATIME_NOW: attr.st_atime = now.tv_sec attr.st_atime_ns = now.tv_nsec else: attr.st_atime = attr.st_atime_ns = None if to_set & FUSE_SET_ATTR_MTIME: attr.st_mtime = stat.st_mtime + GET_MTIME_NS(stat) * 1e-9 attr.st_mtime_ns = stat.st_mtime * 10**9 + GET_MTIME_NS(stat) elif to_set & FUSE_SET_ATTR_MTIME_NOW: attr.st_mtime = now.tv_sec attr.st_mtime_ns = now.tv_nsec else: attr.st_mtime = attr.st_mtime_ns = None if to_set & FUSE_SET_ATTR_MODE: attr.st_mode = stat.st_mode else: attr.st_mode = None if to_set & FUSE_SET_ATTR_UID: attr.st_uid = stat.st_uid else: attr.st_uid = None if to_set & FUSE_SET_ATTR_GID: attr.st_gid = stat.st_gid else: attr.st_gid = None if to_set & FUSE_SET_ATTR_SIZE: attr.st_size = stat.st_size else: attr.st_size = None with lock: attr = operations.setattr(ino, attr) fill_c_stat(attr, &stat_n) timeout = attr.attr_timeout ret = fuse_reply_attr(req, &stat_n, timeout) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('setattr', e, req) if ret != 0: log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino) with gil: cdef int ret cdef char* name try: with lock: target = operations.readlink(ino) name = PyBytes_AsString(target) ret = fuse_reply_readlink(req, name) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('readlink', e, req) if ret != 0: log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode, dev_t rdev) with gil: cdef int ret cdef fuse_entry_param entry try: ctx = get_request_context(req) with lock: attr = operations.mknod(parent, PyBytes_FromString(name), mode, rdev, ctx) fill_entry_param(attr, &entry) ret = fuse_reply_entry(req, &entry) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('mknod', e, req) if ret != 0: log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode) with gil: cdef int ret cdef fuse_entry_param entry try: # Force the entry type to directory. We need to explicitly cast, # because on BSD the S_* are not of type mode_t. mode = ((mode & ~S_IFMT) | S_IFDIR) ctx = get_request_context(req) with lock: attr = operations.mkdir(parent, PyBytes_FromString(name), mode, ctx) fill_entry_param(attr, &entry) ret = fuse_reply_entry(req, &entry) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('mkdir', e, req) if ret != 0: log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: cdef int ret try: with lock: operations.unlink(parent, PyBytes_FromString(name)) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('unlink', e, req) if ret != 0: log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name) with gil: cdef int ret try: with lock: operations.rmdir(parent, PyBytes_FromString(name)) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('rmdir', e, req) if ret != 0: log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, const_char *name) with gil: cdef int ret cdef fuse_entry_param entry try: ctx = get_request_context(req) with lock: attr = operations.symlink(parent, PyBytes_FromString(name), PyBytes_FromString(link), ctx) fill_entry_param(attr, &entry) ret = fuse_reply_entry(req, &entry) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('symlink', e, req) if ret != 0: log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, fuse_ino_t newparent, const_char *newname) with gil: cdef int ret try: with lock: operations.rename(parent, PyBytes_FromString(name), newparent, PyBytes_FromString(newname)) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('rename', e, req) if ret != 0: log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, const_char *newname) with gil: cdef int ret cdef fuse_entry_param entry try: with lock: attr = operations.link(ino, newparent, PyBytes_FromString(newname)) fill_entry_param(attr, &entry) ret = fuse_reply_entry(req, &entry) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('link', e, req) if ret != 0: log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: cdef int ret try: with lock: fi.fh = operations.open(ino, fi.flags) # Cached file data does not need to be invalidated. # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ fi.keep_cache = 1 ret = fuse_reply_open(req, fi) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('open', e, req) if ret != 0: log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi) with gil: cdef int ret cdef ssize_t len_ cdef char* cbuf try: with lock: buf = operations.read(fi.fh, off, size) PyBytes_AsStringAndSize(buf, &cbuf, &len_) ret = fuse_reply_buf(req, cbuf, len_) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('read', e, req) if ret != 0: log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, size_t size, off_t off, fuse_file_info *fi) with gil: cdef int ret cdef size_t len_ # GCC thinks this may end up uninitialized len_ = 0 try: pbuf = PyBytes_FromStringAndSize(buf, size) with lock: len_ = operations.write(fi.fh, off, pbuf) ret = fuse_reply_write(req, len_) if ret != 0: log.error('fuse_write(): fuse_reply_write failed with %s', strerror(-ret)) except FUSEError as e: ret = fuse_reply_err(req, e.errno) if ret != 0: log.error('fuse_write(): fuse_reply_err(%d) failed with %s', strerror(-ret), e.errno) except BaseException as e: ret = handle_exc('write', e, req) if ret != 0: log.error('fuse_write(): fuse_reply_err failed with %s after exception', strerror(-ret)) cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: cdef int ret try: with lock: operations.flush(fi.fh) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('flush', e, req) if ret != 0: log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: cdef int ret try: with lock: operations.release(fi.fh) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('release', e, req) if ret != 0: log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi) with gil: cdef int ret try: with lock: operations.fsync(fi.fh, datasync != 0) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('fsync', e, req) if ret != 0: log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: cdef int ret try: with lock: fi.fh = operations.opendir(ino) ret = fuse_reply_open(req, fi) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('opendir', e, req) if ret != 0: log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi) with gil: cdef int ret cdef char *cname cdef char *buf cdef size_t len_, acc_size cdef c_stat stat # GCC thinks this may end up uninitialized ret = 0 try: acc_size = 0 buf = NULL with lock: for (name, attr, next_) in operations.readdir(fi.fh, off): if buf == NULL: buf = stdlib.malloc(size * sizeof(char)) cname = PyBytes_AsString(name) fill_c_stat(attr, &stat) len_ = fuse_add_direntry(req, buf + acc_size, size - acc_size, cname, &stat, next_) if len_ > (size - acc_size): break acc_size += len_ ret = fuse_reply_buf(req, buf, acc_size) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('readdir', e, req) finally: if buf != NULL: stdlib.free(buf) if ret != 0: log.error('fuse_readdir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) with gil: cdef int ret try: with lock: operations.releasedir(fi.fh) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('releasedir', e, req) if ret != 0: log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi) with gil: cdef int ret try: with lock: operations.fsyncdir(fi.fh, datasync != 0) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('fsyncdir', e, req) if ret != 0: log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino) with gil: cdef int ret cdef statvfs cstats # We don't set all the components string.memset(&cstats, 0, sizeof(cstats)) try: with lock: stats = operations.statfs() fill_statvfs(stats, &cstats) ret = fuse_reply_statfs(req, &cstats) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('statfs', e, req) if ret != 0: log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) IF TARGET_PLATFORM == 'darwin': cdef void fuse_setxattr_darwin (fuse_req_t req, fuse_ino_t ino, const_char *cname, const_char *cvalue, size_t size, int flags, uint32_t position) with gil: cdef int ret if position != 0: log.error('fuse_setxattr(): non-zero position (%d) not supported', position) ret = fuse_reply_err(req, errno.EIO) if ret != 0: log.error('fuse_setxattr(): fuse_reply_err failed with %s', strerror(-ret)) return # Filter out flags that don't make any sense for a FUSE # file system, but that FUSE4x nevertheless stupidly # passes through. # (cf. https://groups.google.com/d/msg/fuse4x/bRnh7J_nsts/Z7raJ06DB4sJ) flags &= ~(xattr.XATTR_NOFOLLOW | xattr.XATTR_NODEFAULT | xattr.XATTR_NOSECURITY) fuse_setxattr(req, ino, cname, cvalue, size, flags) cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, const_char *cvalue, size_t size, int flags) with gil: cdef int ret try: name = PyBytes_FromString(cname) value = PyBytes_FromStringAndSize(cvalue, size) # Special case for deadlock debugging if ino == FUSE_ROOT_ID and string.strcmp(cname, 'fuse_stacktrace') == 0: operations.stacktrace() else: IF TARGET_PLATFORM == 'freebsd': # No known flags with lock: operations.setxattr(ino, name, value) ELSE: # Make sure we know all the flags if flags & ~(xattr.XATTR_CREATE | xattr.XATTR_REPLACE): raise ValueError('unknown flag(s): %o' % flags) with lock: if flags & xattr.XATTR_CREATE: # Attribute must not exist try: operations.getxattr(ino, name) except FUSEError as e: if e.errno != errno.ENOATTR: raise else: raise FUSEError(errno.EEXIST) elif flags & xattr.XATTR_REPLACE: # Attribute must exist operations.getxattr(ino, name) operations.setxattr(ino, name, value) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('setxattr', e, req) if ret != 0: log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) IF TARGET_PLATFORM == 'darwin': cdef void fuse_getxattr_darwin (fuse_req_t req, fuse_ino_t ino, const_char *cname, size_t size, uint32_t position) with gil: cdef int ret if position != 0: log.error('fuse_getxattr(): non-zero position (%d) not supported' % position) ret = fuse_reply_err(req, errno.EIO) if ret != 0: log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) else: fuse_getxattr(req, ino, cname, size) cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, size_t size) with gil: cdef int ret cdef ssize_t len_ cdef char *cbuf try: name = PyBytes_FromString(cname) with lock: buf = operations.getxattr(ino, name) PyBytes_AsStringAndSize(buf, &cbuf, &len_) if size == 0: ret = fuse_reply_xattr(req, len_) elif len_ <= size: ret = fuse_reply_buf(req, cbuf, len_) else: ret = fuse_reply_err(req, errno.ERANGE) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('getxattr', e, req) if ret != 0: log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size) with gil: cdef int ret cdef ssize_t len_ cdef char *cbuf try: with lock: buf = b'\0'.join(operations.listxattr(ino)) + b'\0' PyBytes_AsStringAndSize(buf, &cbuf, &len_) if len_ == 1: # No attributes len_ = 0 if size == 0: ret = fuse_reply_xattr(req, len_) elif len_ <= size: ret = fuse_reply_buf(req, cbuf, len_) else: ret = fuse_reply_err(req, errno.ERANGE) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('listxattr', e, req) if ret != 0: log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *cname) with gil: cdef int ret try: name = PyBytes_FromString(cname) with lock: operations.removexattr(ino, name) ret = fuse_reply_err(req, 0) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('removexattr', e, req) if ret != 0: log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask) with gil: cdef int ret try: ctx = get_request_context(req) with lock: allowed = operations.access(ino, mask, ctx) if allowed: ret = fuse_reply_err(req, 0) else: ret = fuse_reply_err(req, EPERM) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('access', e, req) if ret != 0: log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *cname, mode_t mode, fuse_file_info *fi) with gil: cdef int ret cdef fuse_entry_param entry try: ctx = get_request_context(req) name = PyBytes_FromString(cname) with lock: (fi.fh, attr) = operations.create(parent, name, mode, fi.flags, ctx) # Cached file data does not need to be invalidated. # http://article.gmane.org/gmane.comp.file-systems.fuse.devel/5325/ fi.keep_cache = 1 fill_entry_param(attr, &entry) ret = fuse_reply_create(req, &entry, fi) except FUSEError as e: ret = fuse_reply_err(req, e.errno) except BaseException as e: ret = handle_exc('create', e, req) if ret != 0: log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) llfuse-0.41.1/src/llfuse/lock.c0000664000175000017500000000753012557232665017752 0ustar nikrationikratio00000000000000/* lock.c This file provides the plain C components for the global lock. Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. */ #define TRUE (1==1) #define FALSE (0==1) #include #include #ifdef __MACH__ #include #endif #define GIGA ((long)1e9) int acquire(double timeout); int release(void); int c_yield(int count); // Who was the last to acquire the lock static pthread_t lock_owner; // Is the lock currently taken static int lock_taken = FALSE; /* This variable indicates how many threads are currently waiting for * the lock. */ static int lock_wanted = 0; /* Mutex for protecting access to lock_wanted, lock_owner and * lock_taken */ static pthread_mutex_t mutex; /* Condition even to notify when the lock becomes available */ static pthread_cond_t cond; void init_lock(void) { pthread_cond_init(&cond, NULL); pthread_mutex_init(&mutex, NULL); } int acquire(double timeout) { int ret; struct timespec abstime; #ifdef __MACH__ struct timeval tv; #endif pthread_t me = pthread_self(); if(timeout != 0) { #ifdef __MACH__ ret = gettimeofday(&tv, NULL); if(ret != 0) return ret; abstime.tv_sec = tv.tv_sec; abstime.tv_nsec = tv.tv_usec * 1000; #else ret = clock_gettime(CLOCK_REALTIME, &abstime); if(ret != 0) return ret; #endif abstime.tv_nsec += (long)(timeout - (int) timeout) * GIGA; if(abstime.tv_nsec >= GIGA) { abstime.tv_sec += abstime.tv_nsec / GIGA; abstime.tv_nsec = abstime.tv_nsec % GIGA; } abstime.tv_sec += (int) timeout; } ret = pthread_mutex_lock(&mutex); if(ret != 0) return ret; if(lock_taken) { if(pthread_equal(lock_owner, me)) { pthread_mutex_unlock(&mutex); return EDEADLK; } lock_wanted++; /* We need while here even though pthread_cond_signal wakes * only one thread: * http://stackoverflow.com/questions/8378789/forcing-a-thread-context-switch * http://en.wikipedia.org/wiki/Spurious_wakeup */ if(timeout == 0) while(lock_taken) pthread_cond_wait(&cond, &mutex); else while(lock_taken) { ret = pthread_cond_timedwait(&cond, &mutex, &abstime); if(ret == ETIMEDOUT) { lock_wanted--; pthread_mutex_unlock(&mutex); return ret; } } lock_wanted--; } lock_taken = TRUE; lock_owner = me; return pthread_mutex_unlock(&mutex); } int release(void) { int ret; if(!lock_taken) return EPERM; if(!pthread_equal(lock_owner, pthread_self())) return EPERM; ret = pthread_mutex_lock(&mutex); if(ret != 0) return ret; lock_taken = FALSE; if(lock_wanted > 0) { pthread_cond_signal(&cond); } return pthread_mutex_unlock(&mutex); } int c_yield(int count) { int ret; int i; pthread_t me = pthread_self(); if(!lock_taken || !pthread_equal(lock_owner, me)) return EPERM; ret = pthread_mutex_lock(&mutex); if(ret != 0) return ret; for(i=0; i < count; i++) { if(lock_wanted == 0) break; lock_taken = FALSE; lock_wanted++; pthread_cond_signal(&cond); // See acquire() for why 'while' is required do { pthread_cond_wait(&cond, &mutex); } while(lock_taken); lock_wanted--; if(lock_taken) { pthread_mutex_unlock(&mutex); return EPROTO; } if(pthread_equal(lock_owner, me)) { pthread_mutex_unlock(&mutex); return ENOMSG; } lock_taken = TRUE; lock_owner = me; } return pthread_mutex_unlock(&mutex); } llfuse-0.41.1/src/llfuse/misc.pxi0000664000175000017500000002352112557232665020331 0ustar nikrationikratio00000000000000''' misc.pxi This file defines various functions that are used internally by LLFUSE. It is included by llfuse.pyx. Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' cdef object fill_entry_param(object attr, fuse_entry_param* entry): entry.ino = attr.st_ino entry.generation = attr.generation entry.entry_timeout = attr.entry_timeout entry.attr_timeout = attr.attr_timeout fill_c_stat(attr, &entry.attr) cdef object fill_c_stat(object attr, c_stat* stat): # Under OS-X, c_stat has an additional st_flags field. The memset # below sets this to zero without the need for an explicit # platform check (although, admittedly, this explanatory comment # make take even more space than the check would have taken). string.memset(stat, 0, sizeof(c_stat)) stat.st_ino = attr.st_ino stat.st_mode = attr.st_mode stat.st_nlink = attr.st_nlink stat.st_uid = attr.st_uid stat.st_gid = attr.st_gid stat.st_rdev = attr.st_rdev stat.st_size = attr.st_size stat.st_blksize = attr.st_blksize stat.st_blocks = attr.st_blocks if attr.st_atime_ns is not None: stat.st_atime = attr.st_atime_ns / 10**9 SET_ATIME_NS(stat, attr.st_atime_ns % 10**9) else: stat.st_atime = attr.st_atime SET_ATIME_NS(stat, (attr.st_atime - stat.st_atime) * 1e9) if attr.st_ctime_ns is not None: stat.st_ctime = attr.st_ctime_ns / 10**9 SET_CTIME_NS(stat, attr.st_ctime_ns % 10**9) else: stat.st_ctime = attr.st_ctime SET_CTIME_NS(stat, (attr.st_ctime - stat.st_ctime) * 1e9) if attr.st_mtime_ns is not None: stat.st_mtime = attr.st_mtime_ns / 10**9 SET_MTIME_NS(stat, attr.st_mtime_ns % 10**9) else: stat.st_mtime = attr.st_mtime SET_MTIME_NS(stat, (attr.st_mtime - stat.st_mtime) * 1e9) cdef object fill_statvfs(object attr, statvfs* stat): stat.f_bsize = attr.f_bsize stat.f_frsize = attr.f_frsize stat.f_blocks = attr.f_blocks stat.f_bfree = attr.f_bfree stat.f_bavail = attr.f_bavail stat.f_files = attr.f_files stat.f_ffree = attr.f_ffree stat.f_favail = attr.f_favail cdef int handle_exc(char* fn, object e, fuse_req_t req): '''Try to call fuse_reply_err and terminate main loop''' global exc_info if not exc_info: exc_info = sys.exc_info() log.debug('handler raised exception, sending SIGTERM to self.') kill(getpid(), SIGTERM) else: log.exception('Exception after kill:') if req is NULL: return 0 else: return fuse_reply_err(req, errno.EIO) cdef object get_request_context(fuse_req_t req): '''Get RequestContext() object''' cdef const_fuse_ctx* context context = fuse_req_ctx(req) ctx = RequestContext() ctx.pid = context.pid ctx.uid = context.uid ctx.gid = context.gid ctx.umask = context.umask return ctx cdef void init_fuse_ops(): '''Initialize fuse_lowlevel_ops structure''' string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) fuse_ops.init = fuse_init fuse_ops.destroy = fuse_destroy fuse_ops.lookup = fuse_lookup fuse_ops.forget = fuse_forget fuse_ops.getattr = fuse_getattr fuse_ops.setattr = fuse_setattr fuse_ops.readlink = fuse_readlink fuse_ops.mknod = fuse_mknod fuse_ops.mkdir = fuse_mkdir fuse_ops.unlink = fuse_unlink fuse_ops.rmdir = fuse_rmdir fuse_ops.symlink = fuse_symlink fuse_ops.rename = fuse_rename fuse_ops.link = fuse_link fuse_ops.open = fuse_open fuse_ops.read = fuse_read fuse_ops.write = fuse_write fuse_ops.flush = fuse_flush fuse_ops.release = fuse_release fuse_ops.fsync = fuse_fsync fuse_ops.opendir = fuse_opendir fuse_ops.readdir = fuse_readdir fuse_ops.releasedir = fuse_releasedir fuse_ops.fsyncdir = fuse_fsyncdir fuse_ops.statfs = fuse_statfs IF TARGET_PLATFORM == 'darwin': fuse_ops.setxattr = fuse_setxattr_darwin fuse_ops.getxattr = fuse_getxattr_darwin ELSE: fuse_ops.setxattr = fuse_setxattr fuse_ops.getxattr = fuse_getxattr fuse_ops.listxattr = fuse_listxattr fuse_ops.removexattr = fuse_removexattr fuse_ops.access = fuse_access fuse_ops.create = fuse_create cdef make_fuse_args(list args, fuse_args* f_args): cdef char* arg cdef int i cdef ssize_t size args_new = [ b'Python-LLFUSE' ] for el in args: if not isinstance(el, str_t): raise TypeError('fuse options must be of type str') args_new.append(b'-o') args_new.append(el.encode('us-ascii')) args = args_new f_args.argc = len(args) if f_args.argc == 0: f_args.argv = NULL return f_args.allocated = 1 f_args.argv = stdlib.calloc(f_args.argc, sizeof(char*)) if f_args.argv is NULL: cpython.exc.PyErr_NoMemory() try: for (i, el) in enumerate(args): PyBytes_AsStringAndSize(el, &arg, &size) f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) if f_args.argv[i] is NULL: cpython.exc.PyErr_NoMemory() string.strncpy(f_args.argv[i], arg, size+1) except: for i in range(f_args.argc): # Freeing a NULL pointer (if this element has not been allocated # yet) is fine. stdlib.free(f_args.argv[i]) stdlib.free(f_args.argv) raise cdef class Lock: ''' This is the class of lock itself as well as a context manager to execute code while the global lock is being held. ''' def __init__(self): raise TypeError('You should not instantiate this class, use the ' 'provided instance instead.') def acquire(self, timeout=None): '''Acquire global lock If *timeout* is not None, and the lock could not be acquired after waiting for *timeout* seconds, return False. Otherwise return True. ''' cdef int ret cdef int timeout_c if timeout is None: timeout_c = 0 else: timeout_c = timeout with nogil: ret = acquire(timeout_c) if ret == 0: return True elif ret == ETIMEDOUT and timeout != 0: return False elif ret == EDEADLK: raise RuntimeError("Global lock cannot be acquired more than once") elif ret == EPROTO: raise RuntimeError("Lock still taken after receiving unlock notification") elif ret == EINVAL: raise RuntimeError("Lock not initialized") else: raise RuntimeError(strerror(ret)) def release(self): '''Release global lock''' cdef int ret with nogil: ret = release() if ret == 0: return elif ret == EPERM: raise RuntimeError("Lock can only be released by the holding thread") elif ret == EINVAL: raise RuntimeError("Lock not initialized") else: raise RuntimeError(strerror(ret)) def yield_(self, count=1): '''Yield global lock to a different thread The *count* argument may be used to yield the lock up to *count* times if there are still other threads waiting for the lock. ''' cdef int ret cdef int count_c count_c = count with nogil: ret = c_yield(count_c) if ret == 0: return elif ret == EPERM: raise RuntimeError("Lock can only be released by the holding thread") elif ret == EPROTO: raise RuntimeError("Lock still taken after receiving unlock notification") elif ret == ENOMSG: raise RuntimeError("Other thread didn't take lock") elif ret == EINVAL: raise RuntimeError("Lock not initialized") else: raise RuntimeError(strerror(ret)) def __enter__(self): self.acquire() def __exit__(self, exc_type, exc_val, exc_tb): self.release() cdef class NoLockManager: '''Context manager to execute code while the global lock is released''' def __init__(self): raise TypeError('You should not instantiate this class, use the ' 'provided instance instead.') def __enter__ (self): lock.release() def __exit__(self, *a): lock.acquire() def _notify_loop(): '''Read notifications from queue and send to FUSE kernel module''' cdef ssize_t len_ cdef fuse_ino_t ino cdef char *cname while True: req = _notify_queue.get() if req is None: return if isinstance(req, inval_inode_req): ino = req.inode if req.attr_only: with nogil: fuse_lowlevel_notify_inval_inode(channel, ino, -1, 0) else: with nogil: fuse_lowlevel_notify_inval_inode(channel, ino, 0, 0) elif isinstance(req, inval_entry_req): PyBytes_AsStringAndSize(req.name, &cname, &len_) ino = req.inode_p with nogil: fuse_lowlevel_notify_inval_entry(channel, ino, cname, len_) else: raise RuntimeError("Weird request received: %r", req) cdef str2bytes(s): '''Convert *s* to bytes Under Python 2.x, just returns *s*. Under Python 3.x, converts to file system encoding using surrogateescape. ''' if PY_MAJOR_VERSION < 3: return s else: return s.encode(fse, 'surrogateescape') cdef bytes2str(s): '''Convert *s* to str Under Python 2.x, just returns *s*. Under Python 3.x, converts from file system encoding using surrogateescape. ''' if PY_MAJOR_VERSION < 3: return s else: return s.decode(fse, 'surrogateescape') llfuse-0.41.1/src/llfuse/pyapi.py0000644000175000017500000005025712563732712020347 0ustar nikrationikratio00000000000000# -*- coding: utf-8 -*- ''' pyapi.py Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from __future__ import division, print_function, absolute_import import os import errno import logging import stat log = logging.getLogger('llfuse') def strerror(errno): try: return os.strerror(errno) except ValueError: return 'errno: %d' % errno class RequestContext: ''' Instances of this class are passed to some `Operations` methods to provide information about the caller of the syscall that initiated the request. ''' __slots__ = [ 'uid', 'pid', 'gid', 'umask' ] def __init__(self): for name in self.__slots__: setattr(self, name, None) class EntryAttributes: ''' Instances of this class store attributes of directory entries. Most of the attributes correspond to the elements of the ``stat`` C struct as returned by e.g. ``fstat`` and should be self-explanatory. The access, modification and creation times may be specified either in nanoseconds (via the *st_Xtime_ns* attributes) or in seconds (via the *st_Xtime* attributes). When times are specified both in seconds and nanoseconds, the nanosecond representation takes precedence. If times are represented in seconds, floating point numbers may be used to achieve sub-second resolution. Nanosecond time stamps must be integers. Note that using integer nanoseconds is more accurately than using float seconds. Request handlers do not need to return objects that inherit from `EntryAttributes` directly as long as they provide the required attributes. ''' # Attributes are documented in rst/data.rst __slots__ = [ 'st_ino', 'generation', 'entry_timeout', 'attr_timeout', 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', 'st_size', 'st_blksize', 'st_blocks', 'st_atime', 'st_atime_ns', 'st_mtime', 'st_mtime_ns', 'st_ctime', 'st_ctime_ns' ] def __init__(self): self.st_ino = None self.generation = 0 self.entry_timeout = 300 self.attr_timeout = 300 self.st_mode = stat.S_IFREG self.st_nlink = 1 self.st_uid = 0 self.st_gid = 0 self.st_rdev = 0 self.st_size = 0 self.st_blksize = 4096 self.st_blocks = 0 self.st_atime = 0 self.st_mtime = 0 self.st_ctime = 0 self.st_atime_ns = None self.st_mtime_ns = None self.st_ctime_ns = None class StatvfsData: ''' Instances of this class store information about the file system. The attributes correspond to the elements of the ``statvfs`` struct, see :manpage:`statvfs(2)` for details. Request handlers do not need to return objects that inherit from `StatvfsData` directly as long as they provide the required attributes. ''' # Attributes are documented in rst/operations.rst __slots__ = [ 'f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bavail', 'f_files', 'f_ffree', 'f_favail' ] def __init__(self): for name in self.__slots__: setattr(self, name, None) class FUSEError(Exception): ''' This exception may be raised by request handlers to indicate that the requested operation could not be carried out. The system call that resulted in the request (if any) will then fail with error code *errno_*. ''' __slots__ = [ 'errno' ] def __init__(self, errno_): super(FUSEError, self).__init__() self.errno = errno_ def __str__(self): return strerror(self.errno) class Operations(object): ''' This class defines the general and request handler methods that an Python-LLFUSE file system may implement. If a particular request handler has not been implemented, it must raise `FUSEError` with an errorcode of `errno.ENOSYS`. Further requests of this type will then be handled directly by the FUSE kernel module without calling the handler again. It is recommended that file systems are derived from this class and only overwrite the handlers that they actually implement. (The default implementations defined in this class all just raise the not-implemented exception). The only exception that request handlers are allowed to raise is `FUSEError`. This will cause the specified errno to be returned by the syscall that is being handled. Note that all character data (directory entry names, extended attribute names and values, symbolic link targets etc) are passed as `bytes` and must be returned as `bytes`. This applies to both running under Python 2.x and 3.x ''' def init(self): '''Initialize operations This function will be called just before the file system starts handling requests. It must not raise any exceptions (including `FUSEError`, since this method is not handling a particular syscall). ''' pass def destroy(self): '''Clean up operations. This method will be called when `llfuse.close` has been called and the file system is about to be unmounted. Since this handler is thus *not* run as part of the main loop, it is also *not* called with the global lock acquired (unless the caller of `llfuse.close` already holds the lock). This method must not raise any exceptions (including `FUSEError`, since this method is not handling a particular syscall). ''' pass def lookup(self, parent_inode, name): '''Look up a directory entry by name and get its attributes. If the entry *name* does not exist in the directory with inode *parent_inode*, this method must raise `FUSEError` with an errno of `errno.ENOENT`. Otherwise it must return an `EntryAttributes` instance. Once an inode has been returned by `lookup`, `create`, `symlink`, `link`, `mknod` or `mkdir`, it must be kept by the file system until it receives a `forget` request for the inode. If `unlink` or `rmdir` requests are received prior to the `forget` call, they are expect to remove only the directory entry for the inode and defer removal of the inode itself until the `forget` call. The file system must be able to handle lookups for :file:`.` and :file:`..`, no matter if these entries are returned by `readdir` or not. ''' raise FUSEError(errno.ENOSYS) def forget(self, inode_list): '''Notify about inodes being removed from the kernel cache *inode_list* is a list of ``(inode, nlookup)`` tuples. This method is called when the kernel removes the listed inodes from its internal caches. *nlookup* is the number of times that the inode has been looked up by calling either of the `lookup`, `create`, `symlink`, `mknod`, `link` or `mkdir` methods. The file system is expected to keep track of the number of times an inode has been looked up and forgotten. No request handlers other than `lookup` will be called for an inode with a lookup count of zero. If the lookup count reaches zero after a call to `forget`, the file system is expected to check if there are still directory entries referring to this inode and, if not, delete the inode itself. If the file system is unmounted, it will may not receive `forget` calls for inodes that are still cached. The `destroy` method may be used to clean up any remaining inodes for which no `forget` call has been received. ''' pass def getattr(self, inode): '''Get attributes for *inode* This method should return an `EntryAttributes` instance with the attributes of *inode*. The `~EntryAttributes.entry_timeout` attribute is ignored in this context. ''' raise FUSEError(errno.ENOSYS) def setattr(self, inode, attr): '''Change attributes of *inode* *attr* is an `EntryAttributes` instance with the new attributes. Only the attributes `~EntryAttributes.st_size`, `~EntryAttributes.st_mode`, `~EntryAttributes.st_uid`, `~EntryAttributes.st_gid`, `~EntryAttributes.st_atime` and `~EntryAttributes.st_mtime` are relevant. Unchanged attributes will have a value `None`. The method should return a new `EntryAttributes` instance with the updated attributes (i.e., all attributes except for `~EntryAttributes.entry_timeout` should be set). ''' raise FUSEError(errno.ENOSYS) def readlink(self, inode): '''Return target of symbolic link The return value must have type `bytes`. ''' raise FUSEError(errno.ENOSYS) def mknod(self, parent_inode, name, mode, rdev, ctx): '''Create (possibly special) file *ctx* will be a `RequestContext` instance. The method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. Once an inode has been returned by `lookup`, `create`, `symlink`, `link`, `mknod` or `mkdir`, it must be kept by the file system until it receives a `forget` request for the inode. If `unlink` or `rmdir` requests are received prior to the `forget` call, they are expect to remove only the directory entry for the inode and defer removal of the inode itself until the `forget` call. ''' raise FUSEError(errno.ENOSYS) def mkdir(self, parent_inode, name, mode, ctx): '''Create a directory *ctx* will be a `RequestContext` instance. The method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. Once an inode has been returned by `lookup`, `create`, `symlink`, `link`, `mknod` or `mkdir`, it must be kept by the file system until it receives a `forget` request for the inode. If `unlink` or `rmdir` requests are received prior to the `forget` call, they are expect to remove only the directory entry for the inode and defer removal of the inode itself until the `forget` call. ''' raise FUSEError(errno.ENOSYS) def unlink(self, parent_inode, name): '''Remove a (possibly special) file If the file system has received a `lookup`, but no `forget` call for this file yet, `unlink` is expected to remove only the directory entry and defer removal of the inode with the actual file contents and metadata until the `forget` call is received. Note that an unlinked file may also appear again if it gets a new directory entry by the `link` method. ''' raise FUSEError(errno.ENOSYS) def rmdir(self, inode_parent, name): '''Remove a directory If the file system has received a `lookup`, but no `forget` call for this file yet, `unlink` is expected to remove only the directory entry and defer removal of the inode with the actual file contents and metadata until the `forget` call is received. ''' raise FUSEError(errno.ENOSYS) def symlink(self, inode_parent, name, target, ctx): '''Create a symbolic link *ctx* will be a `RequestContext` instance. The method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. Once an inode has been returned by `lookup`, `create`, `symlink`, `link`, `mknod` or `mkdir`, it must be kept by the file system until it receives a `forget` request for the inode. If `unlink` or `rmdir` requests are received prior to the `forget` call, they are expect to remove only the directory entry for the inode and defer removal of the inode itself until the `forget` call. ''' raise FUSEError(errno.ENOSYS) def rename(self, inode_parent_old, name_old, inode_parent_new, name_new): '''Rename a directory entry If *name_new* already exists, it should be overwritten. If the file system has received a `lookup`, but no `forget` call for the file that is about to be overwritten, `rename` is expected to only overwrite the directory entry and defer removal of the old inode with the its contents and metadata until the `forget` call is received. ''' raise FUSEError(errno.ENOSYS) def link(self, inode, new_parent_inode, new_name): '''Create a hard link. The method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. Once an inode has been returned by `lookup`, `create`, `symlink`, `link`, `mknod` or `mkdir`, it must be kept by the file system until it receives a `forget` request for the inode. If `unlink` or `rmdir` requests are received prior to the `forget` call, they are expect to remove only the directory entry for the inode and defer removal of the inode itself until the `forget` call. ''' raise FUSEError(errno.ENOSYS) def open(self, inode, flags): '''Open a file. *flags* will be a bitwise or of the open flags described in the :manpage:`open(2)` manpage and defined in the `os` module (with the exception of ``O_CREAT``, ``O_EXCL``, ``O_NOCTTY`` and ``O_TRUNC``) This method should return an integer file handle. The file handle will be passed to the `read`, `write`, `flush`, `fsync` and `release` methods to identify the open file. ''' raise FUSEError(errno.ENOSYS) def read(self, fh, off, size): '''Read *size* bytes from *fh* at position *off* This function should return exactly the number of bytes requested except on EOF or error, otherwise the rest of the data will be substituted with zeroes. ''' raise FUSEError(errno.ENOSYS) def write(self, fh, off, buf): '''Write *buf* into *fh* at *off* This method should return the number of bytes written. If no error occured, this should be exactly :samp:`len(buf)`. ''' raise FUSEError(errno.ENOSYS) def flush(self, fh): '''Handle close() syscall. This method is called whenever a file descriptor is closed. It may be called multiple times for the same open file (e.g. if the file handle has been duplicated). If the file system implements locking, this method must clear all locks belonging to the file handle's owner. ''' raise FUSEError(errno.ENOSYS) def release(self, fh): '''Release open file This method will be called when the last file descriptor of *fh* has been closed. Therefore it will be called exactly once for each `open` call. ''' raise FUSEError(errno.ENOSYS) def fsync(self, fh, datasync): '''Flush buffers for open file *fh* If *datasync* is true, only the file contents should be flushed (in contrast to the metadata about the file). ''' raise FUSEError(errno.ENOSYS) def opendir(self, inode): '''Open a directory. This method should return an integer file handle. The file handle will be passed to the `readdir`, `fsyncdir` and `releasedir` methods to identify the directory. ''' raise FUSEError(errno.ENOSYS) def readdir(self, fh, off): '''Read directory entries This method should return an iterator over the contents of directory *fh*, starting at the entry identified by *off*. Directory entries must be of type `bytes`. The iterator must yield tuples of the form :samp:`({name}, {attr}, {next_})`, where *attr* is an `EntryAttributes` instance and *next_* gives an offset that can be passed as *off* to start a successive `readdir` call at the right position. Iteration may be stopped as soon as enough elements have been retrieved. The method should be prepared for this case. If entries are added or removed during a `readdir` cycle, they may or may not be returned. However, they must not cause other entries to be skipped or returned more than once. :file:`.` and :file:`..` entries may be included but are not required. ''' raise FUSEError(errno.ENOSYS) def releasedir(self, fh): '''Release open directory This method must be called exactly once for each `opendir` call. ''' raise FUSEError(errno.ENOSYS) def fsyncdir(self, fh, datasync): '''Flush buffers for open directory *fh* If *datasync* is true, only the directory contents should be flushed (in contrast to metadata about the directory itself). ''' raise FUSEError(errno.ENOSYS) def statfs(self): '''Get file system statistics The method is expected to return an appropriately filled `StatvfsData` instance. ''' raise FUSEError(errno.ENOSYS) def stacktrace(self): '''Asynchronous debugging This method will be called when the ``fuse_stacktrace`` extended attribute is set on the mountpoint. It will be called without holding the global lock. The default implementation logs the current stack trace of every running Python thread. This can be quite useful to debug file system deadlocks. ''' import sys import traceback code = list() for threadId, frame in sys._current_frames().items(): code.append("\n# ThreadID: %s" % threadId) for filename, lineno, name, line in traceback.extract_stack(frame): code.append('%s:%d, in %s' % (os.path.basename(filename), lineno, name)) if line: code.append(" %s" % (line.strip())) log.error("\n".join(code)) def setxattr(self, inode, name, value): '''Set an extended attribute. The attribute may or may not exist already. ''' raise FUSEError(errno.ENOSYS) def getxattr(self, inode, name): '''Return extended attribute value If the attribute does not exist, the method must raise `FUSEError` with an error code of `ENOATTR`. ''' raise FUSEError(errno.ENOSYS) def listxattr(self, inode): '''Get list of extended attribute names''' raise FUSEError(errno.ENOSYS) def removexattr(self, inode, name): '''Remove extended attribute If the attribute does not exist, the method must raise `FUSEError` with an error code of `ENOATTR`. ''' raise FUSEError(errno.ENOSYS) def access(self, inode, mode, ctx): '''Check if requesting process has *mode* rights on *inode*. *ctx* will be a `RequestContext` instance. The method must return a boolean value. If the ``default_permissions`` mount option is given, this method is not called. ''' raise FUSEError(errno.ENOSYS) def create(self, inode_parent, name, mode, flags, ctx): '''Create a file with permissions *mode* and open it with *flags* *ctx* will be a `RequestContext` instance. The method must return a tuple of the form *(fh, attr)*, where *fh* is a file handle like the one returned by `open` and *attr* is an `EntryAttributes` instance with the attributes of the newly created directory entry. Once an inode has been returned by `lookup`, `create`, `symlink`, `link`, `mknod` or `mkdir`, it must be kept by the file system until it receives a `forget` request for the inode. If `unlink` or `rmdir` requests are received prior to the `forget` call, they are expect to remove only the directory entry for the inode and defer removal of the inode itself until the `forget` call. ''' raise FUSEError(errno.ENOSYS) llfuse-0.41.1/src/llfuse/time.c0000664000175000017500000000262112557232665017754 0ustar nikrationikratio00000000000000/* time.c Functions to access the nanosecond attributes in struct stat in a platform independent way. Stolen from fuse_misc.h. Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. */ /* Linux */ #ifdef HAVE_STRUCT_STAT_ST_ATIM #define GET_ATIME_NS(stbuf) ((stbuf)->st_atim.tv_nsec) #define GET_CTIME_NS(stbuf) ((stbuf)->st_ctim.tv_nsec) #define GET_MTIME_NS(stbuf) ((stbuf)->st_mtim.tv_nsec) #define SET_ATIME_NS(stbuf, val) (stbuf)->st_atim.tv_nsec = (val) #define SET_CTIME_NS(stbuf, val) (stbuf)->st_ctim.tv_nsec = (val) #define SET_MTIME_NS(stbuf, val) (stbuf)->st_mtim.tv_nsec = (val) /* FreeBSD */ #elif defined(HAVE_STRUCT_STAT_ST_ATIMESPEC) #define GET_ATIME_NS(stbuf) ((stbuf)->st_atimespec.tv_nsec) #define GET_CTIME_NS(stbuf) ((stbuf)->st_ctimespec.tv_nsec) #define GET_MTIME_NS(stbuf) ((stbuf)->st_mtimespec.tv_nsec) #define SET_ATIME_NS(stbuf, val) (stbuf)->st_atimespec.tv_nsec = (val) #define SET_CTIME_NS(stbuf, val) (stbuf)->st_ctimespec.tv_nsec = (val) #define SET_MTIME_NS(stbuf, val) (stbuf)->st_mtimespec.tv_nsec = (val) /* No nanosecond resolution */ #else #define GET_ATIME_NS(stbuf) 0 #define GET_CTIME_NS(stbuf) 0 #define GET_MTIME_NS(stbuf) 0 #define SET_ATIME_NS(stbuf, val) do { } while (0) #define SET_CTIME_NS(stbuf, val) do { } while (0) #define SET_MTIME_NS(stbuf, val) do { } while (0) #endif llfuse-0.41.1/src/llfuse/version.c0000664000175000017500000000104412557232665020501 0ustar nikrationikratio00000000000000/* version.c This file provides the plain C components for checking the FUSE version. Since we duplicate the information in the FUSE headers in our *.pxd files, we have to make sure that this information does not get out of sync (which may happen with a new major FUSE version). Copyright © 2013 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. */ #include #if FUSE_MAJOR_VERSION != 2 #error This version of the FUSE library is not yet supported. #endif llfuse-0.41.1/src/llfuse.egg-info/0000775000175000017500000000000012566230333020331 5ustar nikrationikratio00000000000000llfuse-0.41.1/src/llfuse.egg-info/PKG-INFO0000664000175000017500000000533212566230333021431 0ustar nikrationikratio00000000000000Metadata-Version: 1.1 Name: llfuse Version: 0.41.1 Summary: Python bindings for the low-level FUSE API Home-page: https://bitbucket.org/nikratio/python-llfuse/ Author: Nikolaus Rath Author-email: Nikolaus@rath.org License: LGPL Download-URL: https://bitbucket.org/nikratio/python-llfuse/downloads Description: .. NOTE: We cannot use sophisticated ReST syntax (like e.g. :file:`foo`) here because this isn't rendered correctly by PyPi and/or BitBucket. About Python-LLFUSE =================== Python-LLFUSE is a set of Python bindings for the low level FUSE_ API. It requires at least FUSE 2.8.0 and supports both Python 2.x and 3.x. It runs under Linux, OS-X, FreeBSD and NetBSD. Python-LLFUSE releases can be downloaded from PyPi_. The documentation can be `read online`__ and is also included in the ``doc/html`` directory of the Python-LLFUSE tarball. Getting Help ------------ Please report any bugs on the `issue tracker`_. For discussion and questions, please use the general `FUSE mailing list`_. A searchable `mailing list archive`_ is kindly provided by Gmane_. Development Status ------------------ The Python-LLFUSE API is not yet stable and may change from one release to the other. Contributing ------------ The Python-LLFUSE source code is available both on GitHub_ and BitBucket_. .. __: http://pythonhosted.org/llfuse/ .. _FUSE: http://fuse.sourceforge.net/ .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _issue tracker: https://bitbucket.org/nikratio/python-llfuse/issues .. _mailing list archive: http://dir.gmane.org/gmane.comp.file-systems.fuse.devel .. _Gmane: http://www.gmane.org/ .. _PyPi: https://pypi.python.org/pypi/llfuse/ .. _BitBucket: https://bitbucket.org/nikratio/python-llfuse/ .. _GitHub: https://github.com/python-llfuse/main Keywords: FUSE,python Platform: Linux Platform: FreeBSD Platform: OS X Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Filesystems Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Operating System :: POSIX :: Linux Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: POSIX :: BSD :: FreeBSD Provides: llfuse llfuse-0.41.1/src/llfuse.egg-info/SOURCES.txt0000664000175000017500000000431112566230333022214 0ustar nikrationikratio00000000000000Changes.txt LICENSE README.rst setup.cfg setup.py Include/fuse_common.pxd Include/fuse_lowlevel.pxd Include/fuse_opt.pxd Include/libc/__init__.py Include/libc/dirent.pxd Include/libc/errno.pxd Include/libc/xattr.pxd Include/libc/sys/__init__.py Include/libc/sys/stat.pxd Include/libc/sys/statvfs.pxd Include/libc/sys/types.pxd doc/html/.buildinfo doc/html/data.html doc/html/example.html doc/html/fuse_api.html doc/html/genindex.html doc/html/getting_started.html doc/html/index.html doc/html/install.html doc/html/lock.html doc/html/objects.inv doc/html/operations.html doc/html/search.html doc/html/searchindex.js doc/html/_sources/data.txt doc/html/_sources/example.txt doc/html/_sources/fuse_api.txt doc/html/_sources/getting_started.txt doc/html/_sources/index.txt doc/html/_sources/install.txt doc/html/_sources/lock.txt doc/html/_sources/operations.txt doc/html/_static/ajax-loader.gif doc/html/_static/basic.css doc/html/_static/comment-bright.png doc/html/_static/comment-close.png doc/html/_static/comment.png doc/html/_static/default.css doc/html/_static/doctools.js doc/html/_static/down-pressed.png doc/html/_static/down.png doc/html/_static/file.png doc/html/_static/jquery.js doc/html/_static/minus.png doc/html/_static/plus.png doc/html/_static/pygments.css doc/html/_static/searchtools.js doc/html/_static/sidebar.js doc/html/_static/underscore.js doc/html/_static/up-pressed.png doc/html/_static/up.png doc/html/_static/websupport.js examples/lltest.py examples/passthroughfs.py examples/tmpfs.py rst/about.rst rst/conf.py rst/data.rst rst/example.rst rst/fuse_api.rst rst/getting_started.rst rst/index.rst rst/install.rst rst/lock.rst rst/operations.rst rst/_static/.placeholder rst/_templates/localtoc.html src/llfuse/__init__.py src/llfuse/capi.c src/llfuse/capi.pyx src/llfuse/capi_darwin.c src/llfuse/capi_freebsd.c src/llfuse/capi_linux.c src/llfuse/fuse_api.pxi src/llfuse/handlers.pxi src/llfuse/lock.c src/llfuse/misc.pxi src/llfuse/pyapi.py src/llfuse/time.c src/llfuse/version.c src/llfuse.egg-info/PKG-INFO src/llfuse.egg-info/SOURCES.txt src/llfuse.egg-info/dependency_links.txt src/llfuse.egg-info/top_level.txt src/llfuse.egg-info/zip-safe test/conftest.py test/pytest.ini test/test_examples.py util/sphinx_cython.pyllfuse-0.41.1/src/llfuse.egg-info/dependency_links.txt0000664000175000017500000000000112566230333024377 0ustar nikrationikratio00000000000000 llfuse-0.41.1/src/llfuse.egg-info/top_level.txt0000664000175000017500000000000712566230333023060 0ustar nikrationikratio00000000000000llfuse llfuse-0.41.1/src/llfuse.egg-info/zip-safe0000664000175000017500000000000111567502502021761 0ustar nikrationikratio00000000000000 llfuse-0.41.1/test/0000775000175000017500000000000012566230333015535 5ustar nikrationikratio00000000000000llfuse-0.41.1/test/conftest.py0000644000175000017500000000511112566222352017732 0ustar nikrationikratio00000000000000import sys import os.path import logging import pytest # Converted to autouse fixture below if capture is activated def check_test_output(request, capfd): request.capfd = capfd def raise_on_exception_in_out(): # Peek at captured output (stdout, stderr) = capfd.readouterr() sys.stdout.write(stdout) sys.stderr.write(stderr) if ('exception' in stderr.lower() or 'exception' in stdout.lower()): raise AssertionError('Suspicious output to stderr') request.addfinalizer(raise_on_exception_in_out) def pytest_addoption(parser): group = parser.getgroup("general") group._addoption("--installed", action="store_true", default=False, help="Test the installed package.") group = parser.getgroup("terminal reporting") group._addoption("--logdebug", action="store_true", default=False, help="Activate debugging output.") def pytest_configure(config): # Enable stdout and stderr analysis, unless output capture is disabled if config.getoption('capture') != 'no': global check_test_output check_test_output = pytest.fixture(autouse=True)(check_test_output) # If we are running from the source directory, make sure that we load # modules from here basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) if not config.getoption('installed'): llfuse_path = os.path.join(basedir, 'src') if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'llfuse'))): sys.path.insert(0, llfuse_path) # Make sure that called processes use the same path pp = os.environ.get('PYTHONPATH', None) if pp: pp = '%s:%s' (llfuse_path, pp) else: pp = llfuse_path os.environ['PYTHONPATH'] = pp # When running from HG repo, enable all warnings if os.path.exists(os.path.join(basedir, '.hg')): import warnings warnings.resetwarnings() warnings.simplefilter('error') logdebug = config.getoption('logdebug') if logdebug: root_logger = logging.getLogger() formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s ' '%(funcName)s: %(message)s', datefmt="%H:%M:%S") handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.DEBUG) handler.setFormatter(formatter) root_logger.addHandler(handler) root_logger.setLevel(logging.DEBUG) llfuse-0.41.1/test/pytest.ini0000644000175000017500000000007212557246273017575 0ustar nikrationikratio00000000000000[pytest] addopts = --verbose --assert=rewrite --tb=native llfuse-0.41.1/test/test_examples.py0000755000175000017500000002653412561245757021012 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' test_examples.py - Unit tests for Python-LLFUSE. Copyright © 2015 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' if __name__ == '__main__': import pytest import sys sys.exit(pytest.main([__file__] + sys.argv[1:])) import subprocess import os import sys import time import pytest import stat import shutil import platform import filecmp import errno basename = os.path.join(os.path.dirname(__file__), '..') TEST_FILE = __file__ # For Python 2 + 3 compatibility if sys.version_info[0] == 2: subprocess.DEVNULL = open('/dev/null', 'w') def skip_if_no_fuse(): '''Skip test if system/user/environment does not support FUSE''' if platform.system() == 'Darwin': # No working autodetection, just assume it will work. return # Python 2.x: Popen is not a context manager... which = subprocess.Popen(['which', 'fusermount'], stdout=subprocess.PIPE, universal_newlines=True) try: fusermount_path = which.communicate()[0].strip() finally: which.wait() if not fusermount_path or which.returncode != 0: pytest.skip("Can't find fusermount executable") if not os.path.exists('/dev/fuse'): pytest.skip("FUSE kernel module does not seem to be loaded") if os.getuid() == 0: return mode = os.stat(fusermount_path).st_mode if mode & stat.S_ISUID == 0: pytest.skip('fusermount executable not setuid, and we are not root.') try: fd = os.open('/dev/fuse', os.O_RDWR) except OSError as exc: pytest.skip('Unable to open /dev/fuse: %s' % exc.strerror) else: os.close(fd) skip_if_no_fuse() def wait_for_mount(mount_process, mnt_dir): elapsed = 0 while elapsed < 30: if os.path.ismount(mnt_dir): return True if mount_process.poll() is not None: pytest.fail('file system process terminated prematurely') time.sleep(0.1) elapsed += 0.1 pytest.fail("mountpoint failed to come up") def cleanup(mnt_dir): if platform.system() == 'Darwin': subprocess.call(['umount', '-l', mnt_dir], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) else: subprocess.call(['fusermount', '-z', '-u', mnt_dir], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) def umount(mount_process, mnt_dir): if platform.system() == 'Darwin': subprocess.check_call(['umount', '-l', mnt_dir]) else: subprocess.check_call(['fusermount', '-z', '-u', mnt_dir]) assert not os.path.ismount(mnt_dir) # Give mount process a little while to terminate. Popen.wait(timeout) # was only added in 3.3... elapsed = 0 while elapsed < 30: if mount_process.poll() is not None: if mount_process.returncode == 0: return pytest.fail('file system process terminated with code %d' % mount_process.exitcode) time.sleep(0.1) elapsed += 0.1 pytest.fail('mount process did not terminate') def name_generator(__ctr=[0]): __ctr[0] += 1 return 'testfile_%d' % __ctr[0] def test_lltest(tmpdir): mnt_dir = str(tmpdir) cmdline = [sys.executable, os.path.join(basename, 'examples', 'lltest.py'), mnt_dir ] mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True) try: wait_for_mount(mount_process, mnt_dir) assert os.listdir(mnt_dir) == [ 'message' ] filename = os.path.join(mnt_dir, 'message') with open(filename, 'r') as fh: assert fh.read() == 'hello world\n' with pytest.raises(IOError) as exc_info: open(filename, 'r+') assert exc_info.value.errno == errno.EPERM with pytest.raises(IOError) as exc_info: open(filename + 'does-not-exist', 'r+') assert exc_info.value.errno == errno.ENOENT except: cleanup(mnt_dir) raise else: umount(mount_process, mnt_dir) def test_tmpfs(tmpdir): mnt_dir = str(tmpdir) cmdline = [sys.executable, os.path.join(basename, 'examples', 'tmpfs.py'), mnt_dir ] mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True) try: wait_for_mount(mount_process, mnt_dir) tst_write(mnt_dir) tst_mkdir(mnt_dir) tst_symlink(mnt_dir) tst_mknod(mnt_dir) tst_chown(mnt_dir) tst_utimens(mnt_dir) tst_link(mnt_dir) tst_readdir(mnt_dir) tst_statvfs(mnt_dir) tst_truncate(mnt_dir) except: cleanup(mnt_dir) raise else: umount(mount_process, mnt_dir) @pytest.mark.skipif(sys.version_info < (3,3), reason="requires python3.3") def test_passthroughfs(tmpdir): mnt_dir = str(tmpdir.mkdir('mnt')) src_dir = str(tmpdir.mkdir('src')) cmdline = [sys.executable, os.path.join(basename, 'examples', 'passthroughfs.py'), src_dir, mnt_dir ] mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True) try: wait_for_mount(mount_process, mnt_dir) tst_write(mnt_dir) tst_mkdir(mnt_dir) tst_symlink(mnt_dir) tst_mknod(mnt_dir) if os.getuid() == 0: tst_chown(mnt_dir) # Underlying fs may not have full nanosecond resolution tst_utimens(mnt_dir, ns_tol=1000) tst_link(mnt_dir) tst_readdir(mnt_dir) tst_statvfs(mnt_dir) tst_truncate(mnt_dir) tst_passthrough(src_dir, mnt_dir) except: cleanup(mnt_dir) raise else: umount(mount_process, mnt_dir) def checked_unlink(filename, path, isdir=False): fullname = os.path.join(path, filename) if isdir: os.rmdir(fullname) else: os.unlink(fullname) with pytest.raises(OSError) as exc_info: os.stat(fullname) assert exc_info.value.errno == errno.ENOENT assert filename not in os.listdir(path) def tst_mkdir(mnt_dir): dirname = name_generator() fullname = mnt_dir + "/" + dirname os.mkdir(fullname) fstat = os.stat(fullname) assert stat.S_ISDIR(fstat.st_mode) assert os.listdir(fullname) == [] assert fstat.st_nlink in (1,2) assert dirname in os.listdir(mnt_dir) checked_unlink(dirname, mnt_dir, isdir=True) def tst_symlink(mnt_dir): linkname = name_generator() fullname = mnt_dir + "/" + linkname os.symlink("/imaginary/dest", fullname) fstat = os.lstat(fullname) assert stat.S_ISLNK(fstat.st_mode) assert os.readlink(fullname) == "/imaginary/dest" assert fstat.st_nlink == 1 assert linkname in os.listdir(mnt_dir) checked_unlink(linkname, mnt_dir) def tst_mknod(mnt_dir): filename = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, filename) fstat = os.lstat(filename) assert stat.S_ISREG(fstat.st_mode) assert fstat.st_nlink == 1 assert os.path.basename(filename) in os.listdir(mnt_dir) assert filecmp.cmp(TEST_FILE, filename, False) checked_unlink(filename, mnt_dir) def tst_chown(mnt_dir): filename = os.path.join(mnt_dir, name_generator()) os.mkdir(filename) fstat = os.lstat(filename) uid = fstat.st_uid gid = fstat.st_gid uid_new = uid + 1 os.chown(filename, uid_new, -1) fstat = os.lstat(filename) assert fstat.st_uid == uid_new assert fstat.st_gid == gid gid_new = gid + 1 os.chown(filename, -1, gid_new) fstat = os.lstat(filename) assert fstat.st_uid == uid_new assert fstat.st_gid == gid_new checked_unlink(filename, mnt_dir, isdir=True) def tst_write(mnt_dir): name = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, name) assert filecmp.cmp(name, TEST_FILE, False) checked_unlink(name, mnt_dir) def tst_statvfs(mnt_dir): os.statvfs(mnt_dir) def tst_link(mnt_dir): name1 = os.path.join(mnt_dir, name_generator()) name2 = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, name1) assert filecmp.cmp(name1, TEST_FILE, False) os.link(name1, name2) fstat1 = os.lstat(name1) fstat2 = os.lstat(name2) assert fstat1 == fstat2 assert fstat1.st_nlink == 2 assert os.path.basename(name2) in os.listdir(mnt_dir) assert filecmp.cmp(name1, name2, False) os.unlink(name2) fstat1 = os.lstat(name1) assert fstat1.st_nlink == 1 os.unlink(name1) def tst_readdir(mnt_dir): dir_ = os.path.join(mnt_dir, name_generator()) file_ = dir_ + "/" + name_generator() subdir = dir_ + "/" + name_generator() subfile = subdir + "/" + name_generator() os.mkdir(dir_) shutil.copyfile(TEST_FILE, file_) os.mkdir(subdir) shutil.copyfile(TEST_FILE, subfile) listdir_is = os.listdir(dir_) listdir_is.sort() listdir_should = [ os.path.basename(file_), os.path.basename(subdir) ] listdir_should.sort() assert listdir_is == listdir_should os.unlink(file_) os.unlink(subfile) os.rmdir(subdir) os.rmdir(dir_) def tst_truncate(mnt_dir): filename = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, filename) assert filecmp.cmp(filename, TEST_FILE, False) fstat = os.stat(filename) size = fstat.st_size fd = os.open(filename, os.O_RDWR) os.ftruncate(fd, size + 1024) # add > 1 block assert os.stat(filename).st_size == size + 1024 os.ftruncate(fd, size - 1024) # Truncate > 1 block assert os.stat(filename).st_size == size - 1024 os.close(fd) os.unlink(filename) def tst_utimens(mnt_dir, ns_tol=0): filename = os.path.join(mnt_dir, name_generator()) os.mkdir(filename) fstat = os.lstat(filename) atime = fstat.st_atime + 42.28 mtime = fstat.st_mtime - 42.23 if sys.version_info < (3,3): os.utime(filename, (atime, mtime)) else: atime_ns = fstat.st_atime_ns + int(42.28*1e9) mtime_ns = fstat.st_mtime_ns - int(42.23*1e9) os.utime(filename, None, ns=(atime_ns, mtime_ns)) fstat = os.lstat(filename) assert abs(fstat.st_atime - atime) < 1e-3 assert abs(fstat.st_mtime - mtime) < 1e-3 if sys.version_info >= (3,3): assert abs(fstat.st_atime_ns - atime_ns) <= ns_tol assert abs(fstat.st_mtime_ns - mtime_ns) <= ns_tol checked_unlink(filename, mnt_dir, isdir=True) def tst_passthrough(src_dir, mnt_dir): name = name_generator() src_name = os.path.join(src_dir, name) mnt_name = os.path.join(src_dir, name) assert name not in os.listdir(src_dir) assert name not in os.listdir(mnt_dir) with open(src_name, 'w') as fh: fh.write('Hello, world') assert name in os.listdir(src_dir) assert name in os.listdir(mnt_dir) assert os.stat(src_name) == os.stat(mnt_name) name = name_generator() src_name = os.path.join(src_dir, name) mnt_name = os.path.join(src_dir, name) assert name not in os.listdir(src_dir) assert name not in os.listdir(mnt_dir) with open(mnt_name, 'w') as fh: fh.write('Hello, world') assert name in os.listdir(src_dir) assert name in os.listdir(mnt_dir) assert os.stat(src_name) == os.stat(mnt_name) llfuse-0.41.1/util/0000775000175000017500000000000012566230333015533 5ustar nikrationikratio00000000000000llfuse-0.41.1/util/sphinx_cython.py0000664000175000017500000000212612557232665021015 0ustar nikrationikratio00000000000000# -*- coding: utf-8 -*- ''' sphinx_cython.py This module removes C style type declarations from function and method docstrings. It also works around http://trac.cython.org/cython_trac/ticket/812 Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from __future__ import division, print_function, absolute_import import re TYPE_RE = re.compile(r'(int|char|unicode|str|bytes)(?:\s+\*?\s*|\s*\*?\s+)([a-zA-Z_].*)') def setup(app): app.connect('autodoc-process-signature', process_signature) def process_signature(app, what, name, obj, options, signature, return_annotation): # Some unused arguments #pylint: disable=W0613 if signature is None: return (signature, return_annotation) new_params = list() for param in (x.strip() for x in signature[1:-1].split(',')): hit = TYPE_RE.match(param) if hit: new_params.append(hit.group(2)) else: new_params.append(param) return ('(%s)' % ', '.join(new_params), return_annotation) llfuse-0.41.1/Changes.txt0000644000175000017500000001465112566222345016700 0ustar nikrationikratio000000000000002015-08-22, python-llfuse 0.41.1 * Added some files in test/ that were missing in the 0.41 tarball. Tests now support the --installed option, produce prettier output, and check for error messages printed to stderr or stdout. * Python-LLFUSE can now also be built on NetBSD. * Added support for FUSE_SET_ATTR_ATIME_NOW and FUSE_SET_ATTR_MTIME_NOW setattr flags. Previosly, these would be silently ignored. * Fixed an AssertionError in examples/passthroughfs.py 2015-08-20, python-llfuse 0.41 * Fixed a syntax error in contrib/tmpfs.py * Introduced an `llfuse.__version__` attribute. * Added more reasonable default values for `llfuse.EntryAttributes`. * Added new minimal example, `examples/lltest.py`. * Added unit tests. * Added an example for a pass-through file system, `examples/passthroughfs.py`. 2013-11-26, python-llfuse 0.40 * Re-raising an exception from a request handler now works correctly under Python 3. Problems were caused by a Cython bug, but llfuse now works around the issue. * File atime, ctime and mtime can now also be represented as nanosecond integer values for increased resolution. Thanks to nagy.attila@gmail.com for the initial patch. * Python-llfuse no longer includes the setuptools/distribute bootstrap script. This module thus has to be installed manually if not already present on the system. * Duck-typing of the Operations instance is now supported. * Python-llfuse no longer requires a re-compilation of the Cython code (setup.py build_cython step) when compiling for MacOS or FreeBSD. * Extended attributes are now properly supported under FreeBSD. 2013-05-11, llfuse 0.39 * When running under Python 3.x, several functions now work with string objects rather than byte objects: - llfuse.init(): the *mountpoint* argument, and the elements of the *fuse_opts* argument are expected to be of type str. - llfuse.listdir(): the *path* argument is expected to be of type str, and the values returned by the iterator will be of type str as well. - llfuse.getxattr(), llfuse.setxattr(): the *path* and *name* arguments are expected to be of type str. When necessary, values will be converted to the file system encoding using the surrogatescape handler as described in PEP 383 (http://www.python.org/dev/peps/pep-0383/) * Renamed get_off_t_bytes() and get_ino_t_bytes() to get_off_t_bits() and get_ino_t_bits() and documented them. 2013-01-05, llfuse 0.38 * Various small bugfixes. 2011-12-10, llfuse 0.37.1 * Fixed a segfault-causing race condition in Lock.acquire() and Lock.yield(). 2011-12-05, llfuse 0.37 * Explicitly call fuse_chan_destroy() in llfuse.close(), so that the mountpoint becomes inaccessible right away, even while the process is still running. * Added get_ino_t_bytes() and get_off_t_bytes() that return the number of bytes used for representing inode numbers and file offsets. * The yield_() method of the global lock now takes an additional *count* argument that can be used to yield the lock more than once. * Changed implementation of global lock. The global lock is no longer a mutex, but a boolean variable protected by a mutex, and changes are tracked with a condition object. This allows lock.yield() to work properly: if there are other threads waiting for the lock, they are guaranteed to run. If there are no other threads waiting for the lock, execution of the active thread continues immediately. The previous implementation using sched_yield() was mostly broken: threads trying to acquire the global lock were calling pthread_mutex_lock, so they got removed from the kernels runqueue. However, calls to sched_yield() would just put the active thread into the expired runqueue, and calls to pthread_mutex_unlock apparently do not synchronously move the threads waiting for the lock back to a runqueue. Therefore, most of the time the active thread would be the only thread in any runqueue and thus continue to run. * The Operations.forget() method now receives a list of (inode, nlookup) tuples rather than just one such tuple. * invalidate_entry() and invalidate_inode() no longer work synchronously. Instead, the message is put in a queue and send by a background thread. * The acquire() method of the global lock now has an optional *timeout* parameter. * The create() request handler now receives the open flags as an additional parameter. 2011-09-20, llfuse 0.36 * Don't send SIGHUP if exception is encountered in destroy() handler (since at that point, main loop has already terminated and signal handling been reset). * Fix a problem with request handler exceptions being re-raised not only in llfuse.main(), but also in llfuse.close() when running single threaded. 2011-09-14, llfuse 0.35 * Explicitly initialize Python thread support. Previously, calling llfuse.main() resulted in a crash if no Python threads were used before the call. * Removed handle_exc() method. If request handle raise an exception, the main loop now terminates and the exception is re-raised and passed to the caller of llfuse.main(). * llfuse.close() can now leave the mountpoint in an inaccessible state to signal a shutdown due to an internal file system error. * The destroy() request handler is now called without the global lock acquired. This makes sense, because it's not called as part of the main loop but by llfuse.close(). 2011-08-10, llfuse 0.34 * Explicitly cast S_* constants to mode_t to prevent compiler warnings on FreeBSD. * Fixed initialization error under Python 3. 2011-07-03, llfuse 0.33 * Various small bugfixes. 2011-06-04, llfuse 0.32 * Fixed unlink() bug in contrib/example.py * Include src/*.pxi files in release tarball. Were accidentally omitted in previous version. * Moved debian/ directory into separate repository. 2011-05-12, llfuse 0.31 * Use long for storing nanoseconds in file [amc]times, not int. 2011-03-08, llfuse 0.30 * Fixed compile errors with Python 3.0 and 3.1. * Fixed error handling, errno is now read correctly. * Documentation is now shipped in tarball rather than generated during installation. 2010-12-30, llfuse 0.29 * Initial release llfuse-0.41.1/LICENSE0000644000175000017500000006255012505143303015562 0ustar nikrationikratio00000000000000This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. For reference, the full text of the GNU Lesser General Public License Version 2 is included below: GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! llfuse-0.41.1/README.rst0000664000175000017500000000301212566222345016245 0ustar nikrationikratio00000000000000.. NOTE: We cannot use sophisticated ReST syntax (like e.g. :file:`foo`) here because this isn't rendered correctly by PyPi and/or BitBucket. About Python-LLFUSE =================== Python-LLFUSE is a set of Python bindings for the low level FUSE_ API. It requires at least FUSE 2.8.0 and supports both Python 2.x and 3.x. It runs under Linux, OS-X, FreeBSD and NetBSD. Python-LLFUSE releases can be downloaded from PyPi_. The documentation can be `read online`__ and is also included in the ``doc/html`` directory of the Python-LLFUSE tarball. Getting Help ------------ Please report any bugs on the `issue tracker`_. For discussion and questions, please use the general `FUSE mailing list`_. A searchable `mailing list archive`_ is kindly provided by Gmane_. Development Status ------------------ The Python-LLFUSE API is not yet stable and may change from one release to the other. Contributing ------------ The Python-LLFUSE source code is available both on GitHub_ and BitBucket_. .. __: http://pythonhosted.org/llfuse/ .. _FUSE: http://fuse.sourceforge.net/ .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _issue tracker: https://bitbucket.org/nikratio/python-llfuse/issues .. _mailing list archive: http://dir.gmane.org/gmane.comp.file-systems.fuse.devel .. _Gmane: http://www.gmane.org/ .. _PyPi: https://pypi.python.org/pypi/llfuse/ .. _BitBucket: https://bitbucket.org/nikratio/python-llfuse/ .. _GitHub: https://github.com/python-llfuse/main llfuse-0.41.1/setup.py0000755000175000017500000002150112566222351016271 0ustar nikrationikratio00000000000000#!/usr/bin/env python #-*- coding: utf-8 -*- ''' setup.py Installation script for Python-LLFUSE. Copyright © 2010 Nikolaus Rath This file is part of Python-LLFUSE. This work may be distributed under the terms of the GNU LGPL. ''' from __future__ import division, print_function, absolute_import import sys import os import subprocess import warnings # Disable Cython support in setuptools. It fails under some conditions # (http://trac.cython.org/ticket/859), and we have our own build_cython command # anyway. try: import Cython.Distutils.build_ext except ImportError: pass else: # We can't delete Cython.Distutils.build_ext directly, # because the build_ext class (that is imported from # the build_ext module in __init__.py) shadows the # build_ext module. module = sys.modules['Cython.Distutils.build_ext'] del module.build_ext try: import setuptools except ImportError: raise SystemExit('Setuptools package not found. Please install from ' 'https://pypi.python.org/pypi/setuptools') from setuptools import Extension # Add util to load path basedir = os.path.abspath(os.path.dirname(sys.argv[0])) sys.path.insert(0, os.path.join(basedir, 'util')) # When running from HG repo, enable all warnings DEVELOPER_MODE = (os.path.exists(os.path.join(basedir, '.hg')) or os.path.exists(os.path.join(basedir, '.git'))) if DEVELOPER_MODE: print('found hg or git repository, running in developer mode') warnings.simplefilter('default') # Add src to load path, important for Sphinx autodoc # to work properly sys.path.insert(0, os.path.join(basedir, 'src')) LLFUSE_VERSION = '0.41.1' def main(): try: from sphinx.application import Sphinx #pylint: disable-msg=W0612 except ImportError: pass else: fix_docutils() with open(os.path.join(basedir, 'README.rst'), 'r') as fh: long_desc = fh.read() compile_args = pkg_config('fuse', cflags=True, ldflags=False, min_ver='2.8.0') compile_args += ['-DFUSE_USE_VERSION=28', '-Wall', '-Wextra', '-Wconversion', '-Wno-sign-conversion', '-DLLFUSE_VERSION="%s"' % LLFUSE_VERSION] # Enable fatal warnings only when compiling from Mercurial tip. (otherwise # we break forward compatibility because compilation with newer compiler may # fail if additional warnings are added) if DEVELOPER_MODE: compile_args.append('-Werror') # http://bugs.python.org/issue7576 if sys.version_info[0] == 3 and sys.version_info[1] < 2: compile_args.append('-Wno-missing-field-initializers') # http://trac.cython.org/cython_trac/ticket/811 compile_args.append('-Wno-unused-but-set-variable') # http://trac.cython.org/cython_trac/ticket/813 compile_args.append('-Wno-maybe-uninitialized') # http://bugs.python.org/issue969718 if sys.version_info[0] == 2: compile_args.append('-fno-strict-aliasing') link_args = pkg_config('fuse', cflags=False, ldflags=True, min_ver='2.8.0') link_args.append('-lpthread') if os.uname()[0] == 'Linux': link_args.append('-lrt') compile_args.append('-DHAVE_STRUCT_STAT_ST_ATIM') elif os.uname()[0] in ('Darwin', 'FreeBSD', 'NetBSD'): compile_args.append('-DHAVE_STRUCT_STAT_ST_ATIMESPEC') else: print("NOTE: unknown system (%s), nanosecond resolution file times " "will not be available" % os.uname()[0]) setuptools.setup( name='llfuse', zip_safe=True, version=LLFUSE_VERSION, description='Python bindings for the low-level FUSE API', long_description=long_desc, author='Nikolaus Rath', author_email='Nikolaus@rath.org', url='https://bitbucket.org/nikratio/python-llfuse/', download_url='https://bitbucket.org/nikratio/python-llfuse/downloads', license='LGPL', classifiers=['Development Status :: 4 - Beta', 'Intended Audience :: Developers', 'Programming Language :: Python', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: System :: Filesystems', 'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)', 'Operating System :: POSIX :: Linux', 'Operating System :: MacOS :: MacOS X', 'Operating System :: POSIX :: BSD :: FreeBSD'], platforms=[ 'Linux', 'FreeBSD', 'OS X' ], keywords=['FUSE', 'python' ], package_dir={'': 'src'}, packages=setuptools.find_packages('src'), provides=['llfuse'], ext_modules=[Extension('llfuse.capi', ['src/llfuse/capi.c'], extra_compile_args=compile_args, extra_link_args=link_args)], cmdclass={'build_cython': build_cython }, command_options={ 'build_sphinx': { 'version': ('setup.py', LLFUSE_VERSION), 'release': ('setup.py', LLFUSE_VERSION), }} ) def pkg_config(pkg, cflags=True, ldflags=False, min_ver=None): '''Frontend to ``pkg-config``''' if min_ver: cmd = ['pkg-config', pkg, '--atleast-version', min_ver ] if subprocess.call(cmd) != 0: cmd = ['pkg-config', '--modversion', pkg ] proc = subprocess.Popen(cmd, stdout=subprocess.PIPE) version = proc.communicate()[0].strip() if not version: raise SystemExit() # pkg-config generates error message already else: raise SystemExit('%s version too old (found: %s, required: %s)' % (pkg, version, min_ver)) cmd = ['pkg-config', pkg ] if cflags: cmd.append('--cflags') if ldflags: cmd.append('--libs') proc = subprocess.Popen(cmd, stdout=subprocess.PIPE) cflags = proc.stdout.readline().rstrip() proc.stdout.close() if proc.wait() != 0: raise SystemExit() # pkg-config generates error message already return cflags.decode('us-ascii').split() class build_cython(setuptools.Command): user_options = [] boolean_options = [] description = "Compile .pyx to .c" def initialize_options(self): pass def finalize_options(self): pass def run(self): try: from Cython.Compiler.Main import compile as cython_compile from Cython.Compiler import Options as DefaultOptions except ImportError: raise SystemExit('Cython needs to be installed for this command') # Cannot be passed directly to cython_compile() DefaultOptions.warning_errors = True DefaultOptions.fast_fail = True directives = dict() directives.update(DefaultOptions.extra_warnings) directives['embedsignature'] = True directives['language_level'] = 3 # http://trac.cython.org/cython_trac/ticket/714 directives['warn.maybe_uninitialized'] = False options = {'include_path': [ os.path.join(basedir, 'Include') ], 'verbose': True, 'timestamps': False, 'compile_time_env': {}, 'compiler_directives': directives } for sysname in ('linux', 'freebsd', 'darwin'): print('compiling capi.pyx to capi_%s.c...' % (sysname,)) options['compile_time_env']['TARGET_PLATFORM'] = sysname options['output_file'] = os.path.join(basedir, 'src', 'llfuse', 'capi_%s.c' % (sysname,)) res = cython_compile(os.path.join(basedir, 'src', 'llfuse', 'capi.pyx'), full_module_name='llfuse.capi', **options) if res.num_errors != 0: raise SystemExit('Cython encountered errors.') # distutils doesn't know that capi.c #includes other files # and thus does not recompile unless we change the modification # date. os.utime(os.path.join(basedir, 'src', 'llfuse', 'capi.c'), None) def fix_docutils(): '''Work around https://bitbucket.org/birkenfeld/sphinx/issue/1154/''' import docutils.parsers from docutils.parsers import rst old_getclass = docutils.parsers.get_parser_class # Check if bug is there try: old_getclass('rst') except AttributeError: pass else: return def get_parser_class(parser_name): """Return the Parser class from the `parser_name` module.""" if parser_name in ('rst', 'restructuredtext'): return rst.Parser else: return old_getclass(parser_name) docutils.parsers.get_parser_class = get_parser_class assert docutils.parsers.get_parser_class('rst') is rst.Parser if __name__ == '__main__': main() llfuse-0.41.1/PKG-INFO0000664000175000017500000000533212566230333015656 0ustar nikrationikratio00000000000000Metadata-Version: 1.1 Name: llfuse Version: 0.41.1 Summary: Python bindings for the low-level FUSE API Home-page: https://bitbucket.org/nikratio/python-llfuse/ Author: Nikolaus Rath Author-email: Nikolaus@rath.org License: LGPL Download-URL: https://bitbucket.org/nikratio/python-llfuse/downloads Description: .. NOTE: We cannot use sophisticated ReST syntax (like e.g. :file:`foo`) here because this isn't rendered correctly by PyPi and/or BitBucket. About Python-LLFUSE =================== Python-LLFUSE is a set of Python bindings for the low level FUSE_ API. It requires at least FUSE 2.8.0 and supports both Python 2.x and 3.x. It runs under Linux, OS-X, FreeBSD and NetBSD. Python-LLFUSE releases can be downloaded from PyPi_. The documentation can be `read online`__ and is also included in the ``doc/html`` directory of the Python-LLFUSE tarball. Getting Help ------------ Please report any bugs on the `issue tracker`_. For discussion and questions, please use the general `FUSE mailing list`_. A searchable `mailing list archive`_ is kindly provided by Gmane_. Development Status ------------------ The Python-LLFUSE API is not yet stable and may change from one release to the other. Contributing ------------ The Python-LLFUSE source code is available both on GitHub_ and BitBucket_. .. __: http://pythonhosted.org/llfuse/ .. _FUSE: http://fuse.sourceforge.net/ .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _issue tracker: https://bitbucket.org/nikratio/python-llfuse/issues .. _mailing list archive: http://dir.gmane.org/gmane.comp.file-systems.fuse.devel .. _Gmane: http://www.gmane.org/ .. _PyPi: https://pypi.python.org/pypi/llfuse/ .. _BitBucket: https://bitbucket.org/nikratio/python-llfuse/ .. _GitHub: https://github.com/python-llfuse/main Keywords: FUSE,python Platform: Linux Platform: FreeBSD Platform: OS X Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Filesystems Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Operating System :: POSIX :: Linux Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: POSIX :: BSD :: FreeBSD Provides: llfuse llfuse-0.41.1/setup.cfg0000644000175000017500000000020512566230333016372 0ustar nikrationikratio00000000000000[sdist] formats = bztar [build_sphinx] source-dir = rst build-dir = doc [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0