The attr argument of the setattr handler now contains valid values only for the attributes that are to be set.
Previously, the documentation assorted that other attributes would be set to the original (unchanged) values. However, that was actually never the case.
Note: The 1.0 version number does not imply any special stability or an API freeze. It’s a consequence of switching to semantic versioning, where backwards incompatible changes will always result in increased major version.
BACKWARDS INCOMPATIBLE CHANGES:
When running under Python 3.x, several functions now work with string objects rather than byte objects:
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.
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.