Merge pull request #28 from WebAssembly/pch/wit_deps_10_31

wit-deps update

wit/deps.lock

@@ -1,17 +1,17 @@
 [clocks]
 url = "https://github.com/WebAssembly/wasi-clocks/archive/main.tar.gz"
-sha256 = "74844f8bf1d356bb44aab64a2f917d7a3bcb6d6924662d2e3909aeabda01bea6"
-sha512 = "ef21339a60a3f4a37eb48ab81b411c1f2ed11c9b23da04d1e384c07dd4cc75f1a433ce7b46201c693b7a59b51c73d888bc41c78ad204fe32d8a312a9f9a48eb0"
+sha256 = "8d6b9f7a8bf9466bdc68043c33e054878fdf09c1cc69c19c99eeadd3bb257a90"
+sha512 = "21b65d911930c4512bb3caa08459283fc70b1ccc5159313092334cffd6662fb92cfe90577b51829ef363e2d02530802c88f2a1f82db43964d1f8bff7ecbc794b"
 
 [filesystem]
 url = "https://github.com/WebAssembly/wasi-filesystem/archive/main.tar.gz"
-sha256 = "ca8364780922eddd53ec77f9152c77486db3d7052f6a5902ccc1648d5494050c"
-sha512 = "ef05d9d7d5c08bc6a701a65c5af1981f30b2eb5b1c3dc5ca39a69248be8ab7cb3b17c5d181a010149dd491846fa5a7ac4f9165b06e628f31227e02dbdd8b86f5"
+sha256 = "c05155f44cf5798d15a16eaf9cdfb065d05914ed4710421a7448bb61c6decf3a"
+sha512 = "fb30ea13678d3f3d2002b2cc1f6dae99ee6a06eae7c408c0d558f21e5039979dd80c8ced46b1a7629ce8b050820d81462093f7b4a733ff706d0258bf5dea5657"
 
 [io]
 url = "https://github.com/WebAssembly/wasi-io/archive/main.tar.gz"
-sha256 = "a00c29dd57dc224e8ce28b793b19c1b1001dcdbdc229ed451c3df1db91841b34"
-sha512 = "8558085eeb5689209101cdfbc9782953d559ad14ce77260fe2f7cc472482d568f65cad9e6a688d40c634c6c54c608f27e27e481633446114d6fdead93d4e34c5"
+sha256 = "fb76f4449eea54d06b56fc6a7ca988da51bd84a54d2021cf18da67b5e2c7ebcf"
+sha512 = "c005e2a91522958a9537827a49ae344e1cb39d66e85492901a86bcc7e322ba8d0a7f1a02c9b9f840c123b4ad97e297355fac98d4822536d1426d1096dd1d73ac"
 
 [random]
 url = "https://github.com/WebAssembly/wasi-random/archive/main.tar.gz"

wit/deps/clocks/monotonic-clock.wit

@@ -11,22 +11,34 @@
 interface monotonic-clock {
  use wasi:io/poll.{pollable};
 
- /// A timestamp in nanoseconds.
+ /// An instant in time, in nanoseconds. An instant is relative to an
+ /// unspecified initial value, and can only be compared to instances from
+ /// the same monotonic-clock.
  type instant = u64;
 
+ /// A duration of time, in nanoseconds.
+ type duration = u64;
+
  /// Read the current value of the clock.
  ///
  /// The clock is monotonic, therefore calling this function repeatedly will
  /// produce a sequence of non-decreasing values.
  now: func() -> instant;
 
- /// Query the resolution of the clock.
- resolution: func() -> instant;
+ /// Query the resolution of the clock. Returns the duration of time
+ /// corresponding to a clock tick.
+ resolution: func() -> duration;
 
- /// Create a `pollable` which will resolve once the specified time has been
- /// reached.
- subscribe: func(
+ /// Create a `pollable` which will resolve once the specified instant
+ /// occured.
+ subscribe-instant: func(
  when: instant,
- absolute: bool
+ ) -> pollable;
+
+ /// Create a `pollable` which will resolve once the given duration has
+ /// elapsed, starting at the time at which this function was called.
+ /// occured.
+ subscribe-duration: func(
+ when: duration,
  ) -> pollable;
 }

wit/deps/filesystem/types.wit

@@ -23,7 +23,7 @@
 ///
 /// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
 interface types {
- use wasi:io/streams.{input-stream, output-stream};
+ use wasi:io/streams.{input-stream, output-stream, error};
  use wasi:clocks/wall-clock.{datetime};
 
  /// File size or length of a region within a file.
@@ -650,105 +650,6 @@ interface types {
  modes: modes,
  ) -> result<_, error-code>;
 
- /// Request a shared advisory lock for an open file.
- ///
- /// This requests a *shared* lock; more than one shared lock can be held for
- /// a file at the same time.
- ///
- /// If the open file has an exclusive lock, this function downgrades the lock
- /// to a shared lock. If it has a shared lock, this function has no effect.
- ///
- /// This requests an *advisory* lock, meaning that the file could be accessed
- /// by other programs that don't hold the lock.
- ///
- /// It is unspecified how shared locks interact with locks acquired by
- /// non-WASI programs.
- ///
- /// This function blocks until the lock can be acquired.
- ///
- /// Not all filesystems support locking; on filesystems which don't support
- /// locking, this function returns `error-code::unsupported`.
- ///
- /// Note: This is similar to `flock(fd, LOCK_SH)` in Unix.
- lock-shared: func() -> result<_, error-code>;
-
- /// Request an exclusive advisory lock for an open file.
- ///
- /// This requests an *exclusive* lock; no other locks may be held for the
- /// file while an exclusive lock is held.
- ///
- /// If the open file has a shared lock and there are no exclusive locks held
- /// for the file, this function upgrades the lock to an exclusive lock. If the
- /// open file already has an exclusive lock, this function has no effect.
- ///
- /// This requests an *advisory* lock, meaning that the file could be accessed
- /// by other programs that don't hold the lock.
- ///
- /// It is unspecified whether this function succeeds if the file descriptor
- /// is not opened for writing. It is unspecified how exclusive locks interact
- /// with locks acquired by non-WASI programs.
- ///
- /// This function blocks until the lock can be acquired.
- ///
- /// Not all filesystems support locking; on filesystems which don't support
- /// locking, this function returns `error-code::unsupported`.
- ///
- /// Note: This is similar to `flock(fd, LOCK_EX)` in Unix.
- lock-exclusive: func() -> result<_, error-code>;
-
- /// Request a shared advisory lock for an open file.
- ///
- /// This requests a *shared* lock; more than one shared lock can be held for
- /// a file at the same time.
- ///
- /// If the open file has an exclusive lock, this function downgrades the lock
- /// to a shared lock. If it has a shared lock, this function has no effect.
- ///
- /// This requests an *advisory* lock, meaning that the file could be accessed
- /// by other programs that don't hold the lock.
- ///
- /// It is unspecified how shared locks interact with locks acquired by
- /// non-WASI programs.
- ///
- /// This function returns `error-code::would-block` if the lock cannot be
- /// acquired.
- ///
- /// Not all filesystems support locking; on filesystems which don't support
- /// locking, this function returns `error-code::unsupported`.
- ///
- /// Note: This is similar to `flock(fd, LOCK_SH | LOCK_NB)` in Unix.
- try-lock-shared: func() -> result<_, error-code>;
-
- /// Request an exclusive advisory lock for an open file.
- ///
- /// This requests an *exclusive* lock; no other locks may be held for the
- /// file while an exclusive lock is held.
- ///
- /// If the open file has a shared lock and there are no exclusive locks held
- /// for the file, this function upgrades the lock to an exclusive lock. If the
- /// open file already has an exclusive lock, this function has no effect.
- ///
- /// This requests an *advisory* lock, meaning that the file could be accessed
- /// by other programs that don't hold the lock.
- ///
- /// It is unspecified whether this function succeeds if the file descriptor
- /// is not opened for writing. It is unspecified how exclusive locks interact
- /// with locks acquired by non-WASI programs.
- ///
- /// This function returns `error-code::would-block` if the lock cannot be
- /// acquired.
- ///
- /// Not all filesystems support locking; on filesystems which don't support
- /// locking, this function returns `error-code::unsupported`.
- ///
- /// Note: This is similar to `flock(fd, LOCK_EX | LOCK_NB)` in Unix.
- try-lock-exclusive: func() -> result<_, error-code>;
-
- /// Release a shared or exclusive lock on an open file.
- ///
- /// Note: This is similar to `flock(fd, LOCK_UN)` in Unix.
- unlock: func() -> result<_, error-code>;
-
  /// Test whether two descriptors refer to the same filesystem object.
  ///
  /// In POSIX, this corresponds to testing whether the two descriptors have the
@@ -795,4 +696,16 @@ interface types {
  /// Read a single directory entry from a `directory-entry-stream`.
  read-directory-entry: func() -> result<option<directory-entry>, error-code>;
  }
+
+ /// Attempts to extract a filesystem-related `error-code` from the stream
+ /// `error` provided.
+ ///
+ /// Stream operations which return `stream-error::last-operation-failed`
+ /// have a payload with more information about the operation that failed.
+ /// This payload can be passed through to this function to see if there's
+ /// filesystem-related information about the error to return.
+ ///
+ /// Note that this function is fallible because not all stream-related
+ /// errors are filesystem-related errors.
+ filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
 }

wit/deps/io/poll.wit

@@ -3,8 +3,21 @@ package wasi:io;
 /// A poll API intended to let users wait for I/O events on multiple handles
 /// at once.
 interface poll {
- /// A "pollable" handle.
- resource pollable;
+ /// `pollable` epresents a single I/O event which may be ready, or not.
+ resource pollable {
+
+ /// Return the readiness of a pollable. This function never blocks.
+ ///
+ /// Returns `true` when the pollable is ready, and `false` otherwise.
+ ready: func() -> bool;
+
+ /// `block` returns immediately if the pollable is ready, and otherwise
+ /// blocks until ready.
+ ///
+ /// This function is equivalent to calling `poll.poll` on a list
+ /// containing only this pollable.
+ block: func();
+ }
 
  /// Poll for completion on a set of pollables.
  ///
@@ -24,11 +37,5 @@ interface poll {
  /// do any I/O so it doesn't fail. If any of the I/O sources identified by
  /// the pollables has an error, it is indicated by marking the source as
  /// being reaedy for I/O.
- poll-list: func(in: list<borrow<pollable>>) -> list<u32>;
-
- /// Poll for completion on a single pollable.
- ///
- /// This function is similar to `poll-list`, but operates on only a single
- /// pollable. When it returns, the handle is ready for I/O.
- poll-one: func(in: borrow<pollable>);
+ poll: func(in: list<borrow<pollable>>) -> list<u32>;
 }