X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/44c95f99098fa6c6acbfa82d4b6cbc6015eb6e39..fcdea9d131e4ba823ac8b69224d90b8eb5f4ae2e:/services/fuse/arvados_fuse/__init__.py diff --git a/services/fuse/arvados_fuse/__init__.py b/services/fuse/arvados_fuse/__init__.py index 1bfd517798..f1e49f5afc 100644 --- a/services/fuse/arvados_fuse/__init__.py +++ b/services/fuse/arvados_fuse/__init__.py @@ -85,6 +85,8 @@ else: # llfuse >= 0.42 llfuse._notify_queue = Queue.Queue() +LLFUSE_VERSION_0 = llfuse.__version__.startswith('0') + from fusedir import sanitize_filename, Directory, CollectionDirectory, TmpCollectionDirectory, MagicDirectory, TagsDirectory, ProjectDirectory, SharedDirectory, CollectionDirectoryBase from fusefile import StringFile, FuseArvadosFile @@ -154,13 +156,32 @@ class InodeCache(object): def _remove(self, obj, clear): if clear: + # Kernel behavior seems to be that if a file is + # referenced, its parents remain referenced too. This + # means has_ref() exits early when a collection is not + # candidate for eviction. + # + # By contrast, in_use() doesn't increment references on + # parents, so it requires a full tree walk to determine if + # a collection is a candidate for eviction. This takes + # .07s for 240000 files, which becomes a major drag when + # cap_cache is being called several times a second and + # there are multiple non-evictable collections in the + # cache. + # + # So it is important for performance that we do the + # has_ref() check first. + + if obj.has_ref(True): + _logger.debug("InodeCache cannot clear inode %i, still referenced", obj.inode) + return + if obj.in_use(): _logger.debug("InodeCache cannot clear inode %i, in use", obj.inode) return - if obj.has_ref(True): - obj.kernel_invalidate() - _logger.debug("InodeCache sent kernel invalidate inode %i", obj.inode) - return + + obj.kernel_invalidate() + _logger.debug("InodeCache sent kernel invalidate inode %i", obj.inode) obj.clear() # The llfuse lock is released in del_entry(), which is called by @@ -199,7 +220,8 @@ class InodeCache(object): if obj not in self._by_uuid[obj.cache_uuid]: self._by_uuid[obj.cache_uuid].append(obj) self._total += obj.objsize() - _logger.debug("InodeCache touched inode %i (size %i) (uuid %s) total now %i", obj.inode, obj.objsize(), obj.cache_uuid, self._total) + _logger.debug("InodeCache touched inode %i (size %i) (uuid %s) total now %i (%i entries)", + obj.inode, obj.objsize(), obj.cache_uuid, self._total, len(self._entries)) self.cap_cache() def touch(self, obj): @@ -264,17 +286,22 @@ class Inodes(object): del self._entries[entry.inode] with llfuse.lock_released: entry.finalize() - self.invalidate_inode(entry.inode) entry.inode = None else: entry.dead = True _logger.debug("del_entry on inode %i with refcount %i", entry.inode, entry.ref_count) - def invalidate_inode(self, inode): - llfuse.invalidate_inode(inode) + def invalidate_inode(self, entry): + if entry.has_ref(False): + # Only necessary if the kernel has previously done a lookup on this + # inode and hasn't yet forgotten about it. + llfuse.invalidate_inode(entry.inode) - def invalidate_entry(self, inode, name): - llfuse.invalidate_entry(inode, name.encode(self.encoding)) + def invalidate_entry(self, entry, name): + if entry.has_ref(False): + # Only necessary if the kernel has previously done a lookup on this + # inode and hasn't yet forgotten about it. + llfuse.invalidate_entry(entry.inode, name.encode(self.encoding)) def clear(self): self.inode_cache.clear() @@ -371,7 +398,9 @@ class Operations(llfuse.Operations): self.events.close() self.events = None - if llfuse.lock.acquire(): + # Different versions of llfuse require and forbid us to + # acquire the lock here. See #8345#note-37, #10805#note-9. + if LLFUSE_VERSION_0 and llfuse.lock.acquire(): # llfuse < 0.42 self.inodes.clear() llfuse.lock.release() @@ -390,30 +419,33 @@ class Operations(llfuse.Operations): @catch_exceptions def on_event(self, ev): - if 'event_type' not in ev: + if 'event_type' not in ev or ev["event_type"] not in ("create", "update", "delete"): return with llfuse.lock: - new_attrs = (ev.get("properties") or {}).get("new_attributes") or {} - pdh = new_attrs.get("portable_data_hash") - # new_attributes.modified_at currently lacks - # subsecond precision (see #6347) so use event_at - # which should always be the same. - stamp = ev.get("event_at") + properties = ev.get("properties") or {} + old_attrs = properties.get("old_attributes") or {} + new_attrs = properties.get("new_attributes") or {} for item in self.inodes.inode_cache.find_by_uuid(ev["object_uuid"]): item.invalidate() - if stamp and pdh and ev.get("object_kind") == "arvados#collection": - item.update(to_record_version=(stamp, pdh)) - else: - item.update() - - oldowner = ((ev.get("properties") or {}).get("old_attributes") or {}).get("owner_uuid") + if ev.get("object_kind") == "arvados#collection": + pdh = new_attrs.get("portable_data_hash") + # new_attributes.modified_at currently lacks + # subsecond precision (see #6347) so use event_at + # which should always be the same. + stamp = ev.get("event_at") + if (stamp and pdh and item.writable() and + item.collection is not None and + item.collection.modified() and + new_attrs.get("is_trashed") is not True): + item.update(to_record_version=(stamp, pdh)) + + oldowner = old_attrs.get("owner_uuid") newowner = ev.get("object_owner_uuid") for parent in ( self.inodes.inode_cache.find_by_uuid(oldowner) + self.inodes.inode_cache.find_by_uuid(newowner)): - parent.invalidate() - parent.update() + parent.child_event(ev) @catch_exceptions def getattr(self, inode, ctx=None): @@ -425,8 +457,8 @@ class Operations(llfuse.Operations): entry = llfuse.EntryAttributes() entry.st_ino = inode entry.generation = 0 - entry.entry_timeout = 60 if e.allow_dirent_cache else 0 - entry.attr_timeout = 60 if e.allow_attr_cache else 0 + entry.entry_timeout = 0 + entry.attr_timeout = e.time_to_next_poll() if e.allow_attr_cache else 0 entry.st_mode = stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH if isinstance(e, Directory):