ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2024-12-23 07:22:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
ba78cf72ae
genode/repos/os/include/vfs/file_io_service.h

128 lines
3.1 KiB
C
Raw Normal View History

Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
/*
* \brief Interface for operations provided by file I/O service
* \author Norman Feske
Support for suspendable read in VFS and libC The support has two parts. First, a VFS plugin now gets passed an I/O-response handler callback on construction, which informs users of the VFS that an I/O event occurred. This enables, for example, the libC to check if blocking read can be completed. Further, the VFS file I/O interface provides now functions for suspendable reads, i.e., queue_read() and complete_read().
2017-01-31 15:38:23 +00:00
* \author Emery Hemingway
* \author Christian Helmuth
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
* \date 2011-02-17
*/
/*
Support for suspendable read in VFS and libC The support has two parts. First, a VFS plugin now gets passed an I/O-response handler callback on construction, which informs users of the VFS that an I/O event occurred. This enables, for example, the libC to check if blocking read can be completed. Further, the VFS file I/O interface provides now functions for suspendable reads, i.e., queue_read() and complete_read().
2017-01-31 15:38:23 +00:00
* Copyright (C) 2011-2017 Genode Labs GmbH
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
*
* This file is part of the Genode OS framework, which is distributed
Adjust file headers to refer to the AGPLv3
2017-02-20 12:23:52 +00:00
* under the terms of the GNU Affero General Public License version 3.
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
*/
#ifndef _INCLUDE__VFS__FILE_IO_SERVICE_H_
#define _INCLUDE__VFS__FILE_IO_SERVICE_H_
Queued read/write/read_ready in VFS and servers
2017-02-01 20:07:14 +00:00
#include <vfs/vfs_handle.h>
VFS: Replace global response handlers with local handlers Replace the I/O response handler that is passed to the VFS at construction with an object that is dynamically attached to handles. This object shall also accept read-ready notifications, and plugins are encouraged to keep handles awaiting ready-ready notifications separate from handles that await I/O progress. Replace the use of handle lists in plugins with handle queues, this makes the code easier to understand and the ordering of notifications to the application more explicit. These changes replace the use of the Post_signal_hook from all VFS plugins, applications must assume that read-ready and I/O notifications occur during I/O signal dispatch and use an Io_progress_handler at its entrypoints to defer response until after signal dispatching. Fix #3257
2019-03-25 14:41:43 +00:00
namespace Vfs { struct File_io_service; }
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 14:42:15 +00:00
struct Vfs::File_io_service : Interface
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
{
/***********
** Write **
***********/
vfs: simplify File_io_service::write return values This patch removes the 'Insufficient_buffer' exception by returning the WRITE_ERR_WOULD_BLOCK result value instead. It also eliminates the superfluous WRITE_ERR_AGAIN and WRITE_ERR_INTERRUPT codes. Issue #4697
2022-12-06 16:04:26 +00:00
enum Write_result { WRITE_ERR_WOULD_BLOCK, WRITE_ERR_INVALID,
WRITE_ERR_IO, WRITE_OK };
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
virtual Write_result write(Vfs_handle *vfs_handle,
vfs: use 64bit for file offset and size Fixes #1246
2014-09-09 12:32:31 +00:00
char const *buf, file_size buf_size,
file_size &out_count) = 0;
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
/**********
** Read **
**********/
vfs: remove Read_result::READ_ERR_AGAIN The condition is covered by READ_ERR_WOULD_BLOCK. Issue #4706
2022-12-20 11:11:27 +00:00
enum Read_result { READ_ERR_WOULD_BLOCK, READ_ERR_INVALID,
READ_ERR_IO, READ_ERR_INTERRUPT,
READ_QUEUED, READ_OK };
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
Support for suspendable read in VFS and libC The support has two parts. First, a VFS plugin now gets passed an I/O-response handler callback on construction, which informs users of the VFS that an I/O event occurred. This enables, for example, the libC to check if blocking read can be completed. Further, the VFS file I/O interface provides now functions for suspendable reads, i.e., queue_read() and complete_read().
2017-01-31 15:38:23 +00:00
/**
VFS: nonblocking interface The VFS library can be used in single-threaded or multi-threaded environments and depending on that, signals are handled by the same thread which uses the VFS library or possibly by a different thread. If a VFS plugin needs to block to wait for a signal, there is currently no way which works reliably in both environments. For this reason, this commit makes the interface of the VFS library nonblocking, similar to the File_system session interface. The most important changes are: - Directories are created and opened with the 'opendir()' function and the directory entries are read with the recently introduced 'queue_read()' and 'complete_read()' functions. - Symbolic links are created and opened with the 'openlink()' function and the link target is read with the 'queue_read()' and 'complete_read()' functions and written with the 'write()' function. - The 'write()' function does not wait for signals anymore. This can have the effect that data written by a VFS library user has not been processed by a file system server yet when the library user asks for the size of the file or closes it (both done with RPC functions at the file system server). For this reason, a user of the VFS library should request synchronization before calling 'stat()' or 'close()'. To make sure that a file system server has processed all write request packets which a client submitted before the synchronization request, synchronization is now requested at the file system server with a synchronization packet instead of an RPC function. Because of this change, the synchronization interface of the VFS library is now split into 'queue_sync()' and 'complete_sync()' functions. Fixes #2399
2017-08-15 18:51:53 +00:00
* Queue read operation
Support for suspendable read in VFS and libC The support has two parts. First, a VFS plugin now gets passed an I/O-response handler callback on construction, which informs users of the VFS that an I/O event occurred. This enables, for example, the libC to check if blocking read can be completed. Further, the VFS file I/O interface provides now functions for suspendable reads, i.e., queue_read() and complete_read().
2017-01-31 15:38:23 +00:00
*
* \return false if queue is full
vfs: no 'handle_io_response()' in regular VFS functions Calling 'handle_io_response()' in a regular VFS function (in contrast to a post-signal hook) can cause problems if the caller of the VFS function holds a lock which prevents the io response handler from returning. With this commit, the user of the VFS becomes responsible for unblocking threads which might be blocking after a failed 'queue_read()', 'queue_sync()' or 'write()' call. Fixes #2896
2018-07-04 12:09:01 +00:00
*
* If the queue is full, the caller can try again after a previous VFS
* request is completed.
Support for suspendable read in VFS and libC The support has two parts. First, a VFS plugin now gets passed an I/O-response handler callback on construction, which informs users of the VFS that an I/O event occurred. This enables, for example, the libC to check if blocking read can be completed. Further, the VFS file I/O interface provides now functions for suspendable reads, i.e., queue_read() and complete_read().
2017-01-31 15:38:23 +00:00
*/
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 14:42:15 +00:00
virtual bool queue_read(Vfs_handle *, file_size)
Support for suspendable read in VFS and libC The support has two parts. First, a VFS plugin now gets passed an I/O-response handler callback on construction, which informs users of the VFS that an I/O event occurred. This enables, for example, the libC to check if blocking read can be completed. Further, the VFS file I/O interface provides now functions for suspendable reads, i.e., queue_read() and complete_read().
2017-01-31 15:38:23 +00:00
{
return true;
}
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 14:42:15 +00:00
virtual Read_result complete_read(Vfs_handle *, char * /* dst */,
file_size /* in count */,
file_size & /* out count */) = 0;
Support for suspendable read in VFS and libC The support has two parts. First, a VFS plugin now gets passed an I/O-response handler callback on construction, which informs users of the VFS that an I/O event occurred. This enables, for example, the libC to check if blocking read can be completed. Further, the VFS file I/O interface provides now functions for suspendable reads, i.e., queue_read() and complete_read().
2017-01-31 15:38:23 +00:00
Support select in libc VFS plugin by read_ready()
2017-02-01 10:28:15 +00:00
/**
* Return true if the handle has readable data
*/
vfs: make 'File_io_service::read_ready' const ... and replace pointer argument to const reference. Issue #4706
2022-12-07 16:12:21 +00:00
virtual bool read_ready(Vfs_handle const &) const = 0;
Support select in libc VFS plugin by read_ready()
2017-02-01 10:28:15 +00:00
vfs,libc: support write fds in select By adding a 'write_ready' interface following the lines of the existing 'read_ready', VFS plugins become able to propagate the (de-)saturation of I/O buffers to the VFS user. This information is important when using a non-blocking file descriptor for writing into a TCP socket. Once the application observes EAGAIN, it expects a subsequent 'select' call to return as soon as new I/O buffer space becomes available. Before this patch, the select call would always return under this condition, causing an unnecessarily busy write loop. Issue #4697
2022-12-06 18:11:44 +00:00
/**
* Return true if the handle might accept a write operation
*/
virtual bool write_ready(Vfs_handle const &) const = 0;
Queued read/write/read_ready in VFS and servers
2017-02-01 20:07:14 +00:00
/**
* Explicitly indicate interest in read-ready for a handle
*
* For example, the file-system-session plugin can then send READ_READY
* packets to the server.
*
* \return false if notification setup failed
*/
virtual bool notify_read_ready(Vfs_handle *) { return true; }
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
/***************
** Ftruncate **
***************/
vfs: remove File_io_service::General_error Issue #4706
2022-12-20 11:05:01 +00:00
enum Ftruncate_result { FTRUNCATE_ERR_NO_PERM, FTRUNCATE_ERR_INTERRUPT,
FTRUNCATE_ERR_NO_SPACE, FTRUNCATE_OK };
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
vfs: use 64bit for file offset and size Fixes #1246
2014-09-09 12:32:31 +00:00
virtual Ftruncate_result ftruncate(Vfs_handle *vfs_handle, file_size len) = 0;
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
VFS: nonblocking interface The VFS library can be used in single-threaded or multi-threaded environments and depending on that, signals are handled by the same thread which uses the VFS library or possibly by a different thread. If a VFS plugin needs to block to wait for a signal, there is currently no way which works reliably in both environments. For this reason, this commit makes the interface of the VFS library nonblocking, similar to the File_system session interface. The most important changes are: - Directories are created and opened with the 'opendir()' function and the directory entries are read with the recently introduced 'queue_read()' and 'complete_read()' functions. - Symbolic links are created and opened with the 'openlink()' function and the link target is read with the 'queue_read()' and 'complete_read()' functions and written with the 'write()' function. - The 'write()' function does not wait for signals anymore. This can have the effect that data written by a VFS library user has not been processed by a file system server yet when the library user asks for the size of the file or closes it (both done with RPC functions at the file system server). For this reason, a user of the VFS library should request synchronization before calling 'stat()' or 'close()'. To make sure that a file system server has processed all write request packets which a client submitted before the synchronization request, synchronization is now requested at the file system server with a synchronization packet instead of an RPC function. Because of this change, the synchronization interface of the VFS library is now split into 'queue_sync()' and 'complete_sync()' functions. Fixes #2399
2017-08-15 18:51:53 +00:00
/**********
** Sync **
**********/
VFS: add an error to to the Sync_result enum Sync errors can be used to indicate failed writes across the File_system session. Ref #2920
2018-07-23 17:53:09 +00:00
enum Sync_result { SYNC_QUEUED, SYNC_ERR_INVALID, SYNC_OK };
VFS: nonblocking interface The VFS library can be used in single-threaded or multi-threaded environments and depending on that, signals are handled by the same thread which uses the VFS library or possibly by a different thread. If a VFS plugin needs to block to wait for a signal, there is currently no way which works reliably in both environments. For this reason, this commit makes the interface of the VFS library nonblocking, similar to the File_system session interface. The most important changes are: - Directories are created and opened with the 'opendir()' function and the directory entries are read with the recently introduced 'queue_read()' and 'complete_read()' functions. - Symbolic links are created and opened with the 'openlink()' function and the link target is read with the 'queue_read()' and 'complete_read()' functions and written with the 'write()' function. - The 'write()' function does not wait for signals anymore. This can have the effect that data written by a VFS library user has not been processed by a file system server yet when the library user asks for the size of the file or closes it (both done with RPC functions at the file system server). For this reason, a user of the VFS library should request synchronization before calling 'stat()' or 'close()'. To make sure that a file system server has processed all write request packets which a client submitted before the synchronization request, synchronization is now requested at the file system server with a synchronization packet instead of an RPC function. Because of this change, the synchronization interface of the VFS library is now split into 'queue_sync()' and 'complete_sync()' functions. Fixes #2399
2017-08-15 18:51:53 +00:00
/**
* Queue sync operation
*
* \return false if queue is full
vfs: no 'handle_io_response()' in regular VFS functions Calling 'handle_io_response()' in a regular VFS function (in contrast to a post-signal hook) can cause problems if the caller of the VFS function holds a lock which prevents the io response handler from returning. With this commit, the user of the VFS becomes responsible for unblocking threads which might be blocking after a failed 'queue_read()', 'queue_sync()' or 'write()' call. Fixes #2896
2018-07-04 12:09:01 +00:00
*
* If the queue is full, the caller can try again after a previous VFS
* request is completed.
VFS: nonblocking interface The VFS library can be used in single-threaded or multi-threaded environments and depending on that, signals are handled by the same thread which uses the VFS library or possibly by a different thread. If a VFS plugin needs to block to wait for a signal, there is currently no way which works reliably in both environments. For this reason, this commit makes the interface of the VFS library nonblocking, similar to the File_system session interface. The most important changes are: - Directories are created and opened with the 'opendir()' function and the directory entries are read with the recently introduced 'queue_read()' and 'complete_read()' functions. - Symbolic links are created and opened with the 'openlink()' function and the link target is read with the 'queue_read()' and 'complete_read()' functions and written with the 'write()' function. - The 'write()' function does not wait for signals anymore. This can have the effect that data written by a VFS library user has not been processed by a file system server yet when the library user asks for the size of the file or closes it (both done with RPC functions at the file system server). For this reason, a user of the VFS library should request synchronization before calling 'stat()' or 'close()'. To make sure that a file system server has processed all write request packets which a client submitted before the synchronization request, synchronization is now requested at the file system server with a synchronization packet instead of an RPC function. Because of this change, the synchronization interface of the VFS library is now split into 'queue_sync()' and 'complete_sync()' functions. Fixes #2399
2017-08-15 18:51:53 +00:00
*/
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 14:42:15 +00:00
virtual bool queue_sync(Vfs_handle *) { return true; }
VFS: nonblocking interface The VFS library can be used in single-threaded or multi-threaded environments and depending on that, signals are handled by the same thread which uses the VFS library or possibly by a different thread. If a VFS plugin needs to block to wait for a signal, there is currently no way which works reliably in both environments. For this reason, this commit makes the interface of the VFS library nonblocking, similar to the File_system session interface. The most important changes are: - Directories are created and opened with the 'opendir()' function and the directory entries are read with the recently introduced 'queue_read()' and 'complete_read()' functions. - Symbolic links are created and opened with the 'openlink()' function and the link target is read with the 'queue_read()' and 'complete_read()' functions and written with the 'write()' function. - The 'write()' function does not wait for signals anymore. This can have the effect that data written by a VFS library user has not been processed by a file system server yet when the library user asks for the size of the file or closes it (both done with RPC functions at the file system server). For this reason, a user of the VFS library should request synchronization before calling 'stat()' or 'close()'. To make sure that a file system server has processed all write request packets which a client submitted before the synchronization request, synchronization is now requested at the file system server with a synchronization packet instead of an RPC function. Because of this change, the synchronization interface of the VFS library is now split into 'queue_sync()' and 'complete_sync()' functions. Fixes #2399
2017-08-15 18:51:53 +00:00
Follow practices suggested by "Effective C++" The patch adjust the code of the base, base-<kernel>, and os repository. To adapt existing components to fix violations of the best practices suggested by "Effective C++" as reported by the -Weffc++ compiler argument. The changes follow the patterns outlined below: * A class with virtual functions can no longer publicly inherit base classed without a vtable. The inherited object may either be moved to a member variable, or inherited privately. The latter would be used for classes that inherit 'List::Element' or 'Avl_node'. In order to enable the 'List' and 'Avl_tree' to access the meta data, the 'List' must become a friend. * Instead of adding a virtual destructor to abstract base classes, we inherit the new 'Interface' class, which contains a virtual destructor. This way, single-line abstract base classes can stay as compact as they are now. The 'Interface' utility resides in base/include/util/interface.h. * With the new warnings enabled, all member variables must be explicitly initialized. Basic types may be initialized with '='. All other types are initialized with braces '{ ... }' or as class initializers. If basic types and non-basic types appear in a row, it is nice to only use the brace syntax (also for basic types) and align the braces. * If a class contains pointers as members, it must now also provide a copy constructor and assignment operator. In the most cases, one would make them private, effectively disallowing the objects to be copied. Unfortunately, this warning cannot be fixed be inheriting our existing 'Noncopyable' class (the compiler fails to detect that the inheriting class cannot be copied and still gives the error). For now, we have to manually add declarations for both the copy constructor and assignment operator as private class members. Those declarations should be prepended with a comment like this: /* * Noncopyable */ Thread(Thread const &); Thread &operator = (Thread const &); In the future, we should revisit these places and try to replace the pointers with references. In the presence of at least one reference member, the compiler would no longer implicitly generate a copy constructor. So we could remove the manual declaration. Issue #465
2017-12-21 14:42:15 +00:00
virtual Sync_result complete_sync(Vfs_handle *) { return SYNC_OK; }
vfs: add modification time member to directory_service Issue #1784.
2019-03-20 14:01:34 +00:00
/***********************
** Modification time **
***********************/
/**
* Update the modification time of a file
*
* \return true if update attempt was successful
*/
virtual bool update_modification_timestamp(Vfs_handle *, Vfs::Timestamp)
{
return true;
}
Move VFS from noux to 'os/include/vfs' By separating the VFS from Noux, we become able to reuse the VFS for libc-using programs. The most substantial change is the removal of Noux::Sysio data structures from the VFS. Instead, the Noux::Sysio refers to the VFS types now. The new VFS library is located at 'os/include/vfs/'. Furthermore, the patch removes various code duplications related to pseudo file systems that provide a single file (block, zero, random, terminal, null). The new 'Single_file_system' holds the common boilerplate code for those. Issue #999
2014-04-07 14:15:40 +00:00
};
#endif /* _INCLUDE__VFS__FILE_IO_SERVICE_H_ */
Reference in New Issue Copy Permalink