Stream: git-wasmtime

Topic: wasmtime / PR #1561 [WIP]: Introduce strongly-typed syste...

Wasmtime GitHub notifications bot (Apr 20 2020 at 18:45):

kubkon opened PR #1561 from handle-rights to master:

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: OsFile, OsDir, Stdio,
and OsOther. Those primitives are separate structs now, each implementing
a subset of Handle methods, rather than all being an enumeration of some
supertype such as OsHandle. To summarise the structs:

• OsFile represents a regular file, and implements fd-ops
  of Handle trait

• OsDir represents a directory, and primarily implements path-ops, plus
  readdir and some common fd-ops such as fdstat, etc.

• Stdio represents a stdio handle, and implements a subset of fd-ops
  such as fdstat _and_ read_ and write_vectored calls

• OsOther currently represents anything else and implements a set similar
  to that implemented by Stdio

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making OsHandle represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since OsDir
is tricky across OSes, we also have a supertype of OsHandle called
OsDirHandle which may store a DIR* stream pointer (mainly BSD). Last but not
least, the Filetype and Rights are now computed when the resource is created,
rather than every time we call Handle::get_file_type and Handle::get_rights.
Finally, in order to facilitate the latter, I've converted EntryRights into
HandleRights and pushed them into each Handle implementor.

Wasmtime GitHub notifications bot (Apr 20 2020 at 18:48):

kubkon requested sunfishcode for a review on PR #1561.

Wasmtime GitHub notifications bot (Apr 20 2020 at 19:39):

kubkon updated PR #1561 from handle-rights to master:

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: OsFile, OsDir, Stdio,
and OsOther. Those primitives are separate structs now, each implementing
a subset of Handle methods, rather than all being an enumeration of some
supertype such as OsHandle. To summarise the structs:

• OsFile represents a regular file, and implements fd-ops
  of Handle trait

• OsDir represents a directory, and primarily implements path-ops, plus
  readdir and some common fd-ops such as fdstat, etc.

• Stdio represents a stdio handle, and implements a subset of fd-ops
  such as fdstat _and_ read_ and write_vectored calls

• OsOther currently represents anything else and implements a set similar
  to that implemented by Stdio

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making OsHandle represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since OsDir
is tricky across OSes, we also have a supertype of OsHandle called
OsDirHandle which may store a DIR* stream pointer (mainly BSD). Last but not
least, the Filetype and Rights are now computed when the resource is created,
rather than every time we call Handle::get_file_type and Handle::get_rights.
Finally, in order to facilitate the latter, I've converted EntryRights into
HandleRights and pushed them into each Handle implementor.

Wasmtime GitHub notifications bot (Apr 20 2020 at 19:55):

kubkon updated PR #1561 from handle-rights to master:

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: OsFile, OsDir, Stdio,
and OsOther. Those primitives are separate structs now, each implementing
a subset of Handle methods, rather than all being an enumeration of some
supertype such as OsHandle. To summarise the structs:

• OsFile represents a regular file, and implements fd-ops
  of Handle trait

• OsDir represents a directory, and primarily implements path-ops, plus
  readdir and some common fd-ops such as fdstat, etc.

• Stdio represents a stdio handle, and implements a subset of fd-ops
  such as fdstat _and_ read_ and write_vectored calls

• OsOther currently represents anything else and implements a set similar
  to that implemented by Stdio

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making OsHandle represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since OsDir
is tricky across OSes, we also have a supertype of OsHandle called
OsDirHandle which may store a DIR* stream pointer (mainly BSD). Last but not
least, the Filetype and Rights are now computed when the resource is created,
rather than every time we call Handle::get_file_type and Handle::get_rights.
Finally, in order to facilitate the latter, I've converted EntryRights into
HandleRights and pushed them into each Handle implementor.

Wasmtime GitHub notifications bot (Apr 20 2020 at 20:29):

kubkon updated PR #1561 from handle-rights to master:

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: OsFile, OsDir, Stdio,
and OsOther. Those primitives are separate structs now, each implementing
a subset of Handle methods, rather than all being an enumeration of some
supertype such as OsHandle. To summarise the structs:

• OsFile represents a regular file, and implements fd-ops
  of Handle trait

• OsDir represents a directory, and primarily implements path-ops, plus
  readdir and some common fd-ops such as fdstat, etc.

• Stdio represents a stdio handle, and implements a subset of fd-ops
  such as fdstat _and_ read_ and write_vectored calls

• OsOther currently represents anything else and implements a set similar
  to that implemented by Stdio

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making OsHandle represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since OsDir
is tricky across OSes, we also have a supertype of OsHandle called
OsDirHandle which may store a DIR* stream pointer (mainly BSD). Last but not
least, the Filetype and Rights are now computed when the resource is created,
rather than every time we call Handle::get_file_type and Handle::get_rights.
Finally, in order to facilitate the latter, I've converted EntryRights into
HandleRights and pushed them into each Handle implementor.

Wasmtime GitHub notifications bot (Apr 20 2020 at 21:57):

kubkon updated PR #1561 from handle-rights to master:

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: OsFile, OsDir, Stdio,
and OsOther. Those primitives are separate structs now, each implementing
a subset of Handle methods, rather than all being an enumeration of some
supertype such as OsHandle. To summarise the structs:

• OsFile represents a regular file, and implements fd-ops
  of Handle trait

• OsDir represents a directory, and primarily implements path-ops, plus
  readdir and some common fd-ops such as fdstat, etc.

• Stdio represents a stdio handle, and implements a subset of fd-ops
  such as fdstat _and_ read_ and write_vectored calls

• OsOther currently represents anything else and implements a set similar
  to that implemented by Stdio

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making OsHandle represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since OsDir
is tricky across OSes, we also have a supertype of OsHandle called
OsDirHandle which may store a DIR* stream pointer (mainly BSD). Last but not
least, the Filetype and Rights are now computed when the resource is created,
rather than every time we call Handle::get_file_type and Handle::get_rights.
Finally, in order to facilitate the latter, I've converted EntryRights into
HandleRights and pushed them into each Handle implementor.

Wasmtime GitHub notifications bot (Apr 21 2020 at 20:33):

kubkon updated PR #1561 from handle-rights to master:

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: OsFile, OsDir, Stdio,
and OsOther. Those primitives are separate structs now, each implementing
a subset of Handle methods, rather than all being an enumeration of some
supertype such as OsHandle. To summarise the structs:

• OsFile represents a regular file, and implements fd-ops
  of Handle trait

• OsDir represents a directory, and primarily implements path-ops, plus
  readdir and some common fd-ops such as fdstat, etc.

• Stdio represents a stdio handle, and implements a subset of fd-ops
  such as fdstat _and_ read_ and write_vectored calls

• OsOther currently represents anything else and implements a set similar
  to that implemented by Stdio

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making OsHandle represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since OsDir
is tricky across OSes, we also have a supertype of OsHandle called
OsDirHandle which may store a DIR* stream pointer (mainly BSD). Last but not
least, the Filetype and Rights are now computed when the resource is created,
rather than every time we call Handle::get_file_type and Handle::get_rights.
Finally, in order to facilitate the latter, I've converted EntryRights into
HandleRights and pushed them into each Handle implementor.

Wasmtime GitHub notifications bot (Apr 21 2020 at 20:36):

kubkon updated PR #1561 from handle-rights to master:

This commit does a lot of reshuffling and even some more. It introduces
strongly-typed system primitives which are: OsFile, OsDir, Stdio,
and OsOther. Those primitives are separate structs now, each implementing
a subset of Handle methods, rather than all being an enumeration of some
supertype such as OsHandle. To summarise the structs:

• OsFile represents a regular file, and implements fd-ops
  of Handle trait

• OsDir represents a directory, and primarily implements path-ops, plus
  readdir and some common fd-ops such as fdstat, etc.

• Stdio represents a stdio handle, and implements a subset of fd-ops
  such as fdstat _and_ read_ and write_vectored calls

• OsOther currently represents anything else and implements a set similar
  to that implemented by Stdio

This commit is effectively an experiment and an excercise into better
understanding what's going on for each OS resource/type under-the-hood.
It's meant to give us some intuition in order to move on with the idea
of having strongly-typed handles in WASI both in the syscall impl as well
as at the libc level.

Some more minor changes include making OsHandle represent an OS-specific
wrapper for a raw OS handle (Unix fd or Windows handle). Also, since OsDir
is tricky across OSes, we also have a supertype of OsHandle called
OsDirHandle which may store a DIR* stream pointer (mainly BSD). Last but not
least, the Filetype and Rights are now computed when the resource is created,
rather than every time we call Handle::get_file_type and Handle::get_rights.
Finally, in order to facilitate the latter, I've converted EntryRights into
HandleRights and pushed them into each Handle implementor.

Wasmtime GitHub notifications bot (Apr 22 2020 at 08:41):

kubkon requested alexcrichton and sunfishcode for a review on PR #1561.

Wasmtime GitHub notifications bot (Apr 22 2020 at 08:45):

kubkon requested alexcrichton, pchickey, peterhuene and sunfishcode for a review on PR #1561.

Wasmtime GitHub notifications bot (Apr 22 2020 at 08:45):

kubkon requested alexcrichton, pchickey, peterhuene and sunfishcode for a review on PR #1561.

Last updated: Nov 22 2024 at 17:03 UTC