Struct ProcSysNetIpv4Neigh 

pub struct ProcSysNetIpv4Neigh;

Trait Implementations

impl Clone for ProcSysNetIpv4Neigh

fn clone(&self) -> ProcSysNetIpv4Neigh

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl FileOps for ProcSysNetIpv4Neigh

fn is_seekable(&self) -> bool

Returns whether the file is seekable.

fn read( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, _current_task: &CurrentTask, _offset: usize, _data: &mut dyn OutputBuffer, ) -> Result<usize, Errno>

Read from the file at an offset. If the file does not have persistent offsets (either directly, or because it is not seekable), offset will be 0 and can be ignored. Returns the number of bytes read.

fn write( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, _current_task: &CurrentTask, _offset: usize, _data: &mut dyn InputBuffer, ) -> Result<usize, Errno>

Write to the file with an offset. If the file does not have persistent offsets (either directly, or because it is not seekable), offset will be 0 and can be ignored. Returns the number of bytes written.

fn sync( &self, file: &FileObject, _current_task: &CurrentTask, ) -> Result<(), Errno>

Syncs cached state associated with the file descriptor to persistent storage.

fn seek( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, _current_task: &CurrentTask, current_offset: off_t, target: SeekTarget, ) -> Result<off_t, Errno>

Adjust the current_offset if the file is seekable.

fn readdir( &self, locked: &mut Locked<FileOpsCore>, file: &FileObject, current_task: &CurrentTask, sink: &mut dyn DirentSink, ) -> Result<(), Errno>

Respond to a getdents or getdents64 calls.

fn wait_async( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, current_task: &CurrentTask, waiter: &Waiter, _events: FdEvents, _handler: EventHandler, ) -> Option<WaitCanceler>

Establish a one-shot, edge-triggered, asynchronous wait for the given FdEvents for the given file and task. Returns None if this file does not support blocking waits.

fn open( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, _current_task: &CurrentTask, ) -> Result<(), Errno>

Called when the FileObject is opened/created

fn close( self: Box<Self>, _locked: &mut Locked<FileOpsCore>, _file: &FileObjectState, _current_task: &CurrentTask, )

Called when the FileObject is destroyed.

fn flush( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, _current_task: &CurrentTask, )

Called every time close() is called on this file, even if the file is not ready to be released.

fn has_persistent_offsets(&self) -> bool

Returns whether the file has meaningful seek offsets. Returning false is only optimization and will makes FileObject never hold the offset lock when calling read and write.

fn writes_update_seek_offset(&self) -> bool

Returns true if write() operations on the file will update the seek offset.

fn data_sync( &self, file: &FileObject, current_task: &CurrentTask, ) -> Result<(), Errno>

Syncs cached data, and only enough metadata to retrieve said data, to persistent storage.

fn get_memory( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, _current_task: &CurrentTask, _length: Option<usize>, _prot: ProtectionFlags, ) -> Result<Arc<MemoryObject>, Errno>

Returns a VMO representing this file. At least the requested protection flags must be set on the VMO. Reading or writing the VMO must read or write the file. If this is not possible given the requested protection, an error must be returned. The length is a hint for the desired size of the VMO. The returned VMO may be larger or smaller than the requested length. This method is typically called by Self::mmap.

fn mmap( &self, locked: &mut Locked<FileOpsCore>, file: &FileObject, current_task: &CurrentTask, addr: DesiredAddress, memory_offset: u64, length: usize, prot_flags: ProtectionFlags, options: MappingOptions, filename: NamespaceNode, ) -> Result<UserAddress, Errno>

Responds to an mmap call. The default implementation calls Self::get_memory to get a VMO and then maps it with [crate::mm::MemoryManager::map]. Only implement this trait method if your file needs to control mapping, or record where a VMO gets mapped.

fn query_events( &self, _locked: &mut Locked<FileOpsCore>, _file: &FileObject, _current_task: &CurrentTask, ) -> Result<FdEvents, Errno>

The events currently active on this file.

fn ioctl( &self, locked: &mut Locked<Unlocked>, file: &FileObject, current_task: &CurrentTask, request: u32, arg: SyscallArg, ) -> Result<SyscallResult, Errno>

fn fcntl( &self, _file: &FileObject, _current_task: &CurrentTask, cmd: u32, _arg: u64, ) -> Result<SyscallResult, Errno>

fn to_handle( &self, file: &FileObject, current_task: &CurrentTask, ) -> Result<Option<NullableHandle>, Errno>

Return a handle that allows access to this file descritor through the zxio protocols.

fn get_handles( &self, _file: &FileObject, _current_task: &CurrentTask, ) -> Result<Vec<NullableHandle>, Errno>

fn as_thread_group_key( &self, _file: &FileObject, ) -> Result<ThreadGroupKey, Errno>

Returns the associated pid_t.

fn readahead( &self, _file: &FileObject, _current_task: &CurrentTask, _offset: usize, _length: usize, ) -> Result<(), Errno>

fn extra_fdinfo( &self, _locked: &mut Locked<FileOpsCore>, _file: &Arc<ObjectReleaser<FileObject, FileObjectReleaserAction>>, _current_task: &CurrentTask, ) -> Option<BString>

Extra information that is included in the /proc//fdfino/ entry.

impl FsNodeOps for ProcSysNetIpv4Neigh

fn check_access( &self, _locked: &mut Locked<FileOpsCore>, node: &FsNode, current_task: &CurrentTask, permission_flags: PermissionFlags, info: &RwLock<FsNodeInfo>, reason: CheckAccessReason, audit_context: Auditable<'_>, ) -> Result<(), Errno>

Delegate the access check to the node.

fn mkdir( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, name: &FsStr, _mode: FileMode, _owner: FsCred, ) -> Result<FsNodeHandle, Errno>

Create and return the given child node as a subdirectory.

fn mknod( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, name: &FsStr, _mode: FileMode, _dev: DeviceType, _owner: FsCred, ) -> Result<FsNodeHandle, Errno>

Create and return the given child node.

fn create_symlink( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, name: &FsStr, _target: &FsStr, _owner: FsCred, ) -> Result<FsNodeHandle, Errno>

Creates a symlink with the given target path.

fn link( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, name: &FsStr, _child: &FsNodeHandle, ) -> Result<(), Errno>

Create a hard link with the given name to the given child.

fn unlink( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, name: &FsStr, _child: &FsNodeHandle, ) -> Result<(), Errno>

Remove the child with the given name, if the child exists.

fn create_file_ops( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, _flags: OpenFlags, ) -> Result<Box<dyn FileOps>, Errno>

Build the FileOps for the file associated to this node.

fn lookup( &self, _locked: &mut Locked<FileOpsCore>, node: &FsNode, current_task: &CurrentTask, name: &FsStr, ) -> Result<FsNodeHandle, Errno>

Find an existing child node and populate the child parameter. Return the node.

fn create_dir_entry_ops(&self) -> Box<dyn DirEntryOps>

Build the DirEntryOps for a new [DirEntry] that will be associated to this node.

fn create_tmpfile( &self, _node: &FsNode, _current_task: &CurrentTask, _mode: FileMode, _owner: FsCred, ) -> Result<Arc<ObjectReleaser<FsNode, FsNodeReleaserAction>>, Errno>

Creates an anonymous file.

fn readlink( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, ) -> Result<SymlinkTarget, Errno>

Reads the symlink from this node.

fn append_lock_read<'a>( &'a self, locked: &'a mut Locked<BeforeFsNodeAppend>, node: &'a FsNode, current_task: &CurrentTask, ) -> Result<(RwQueueReadGuard<'a, FsNodeAppend>, &'a mut Locked<FsNodeAppend>), Errno>

Acquire the necessary append lock for the operations that depend on them. Should be done before calling allocate or truncate to avoid lock ordering issues.

fn truncate( &self, _locked: &mut Locked<FileOpsCore>, _guard: &AppendLockGuard<'_>, _node: &FsNode, _current_task: &CurrentTask, _length: u64, ) -> Result<(), Errno>

Change the length of the file.

fn allocate( &self, _locked: &mut Locked<FileOpsCore>, _guard: &AppendLockGuard<'_>, _node: &FsNode, _current_task: &CurrentTask, _mode: FallocMode, _offset: u64, _length: u64, ) -> Result<(), Errno>

Manipulate allocated disk space for the file.

fn initial_info(&self, _info: &mut FsNodeInfo)

Update the supplied info with initial state (e.g. size) for the node.

fn fetch_and_refresh_info<'a>( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, info: &'a RwLock<RawSyncRwLock, FsNodeInfo>, ) -> Result<RwLockReadGuard<'a, RawSyncRwLock, FsNodeInfo>, Errno>

Update node.info as needed.

fn sync(&self, _node: &FsNode, _current_task: &CurrentTask) -> Result<(), Errno>

Syncs cached data to persistent storage.

fn update_attributes( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, _info: &FsNodeInfo, _has: zxio_node_attr_zxio_node_attr_has_t, ) -> Result<(), Errno>

Update node attributes persistently.

fn get_xattr( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, _name: &BStr, _max_size: usize, ) -> Result<ValueOrSize<BString>, Errno>

Get an extended attribute on the node.

fn set_xattr( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, _name: &BStr, _value: &BStr, _op: XattrOp, ) -> Result<(), Errno>

Set an extended attribute on the node.

fn remove_xattr( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, _name: &BStr, ) -> Result<(), Errno>

fn list_xattrs( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, _max_size: usize, ) -> Result<ValueOrSize<Vec<BString>>, Errno>

An implementation can systematically return a value. Otherwise, if max_size is 0, it can instead return the size of the 0 separated string needed to represent the value, and can return an ERANGE error if max_size is not 0, and lesser than the required size.

fn forget( self: Box<Self>, _locked: &mut Locked<FileOpsCore>, _current_task: &CurrentTask, _info: FsNodeInfo, ) -> Result<(), Errno>

Called when the FsNode is freed by the Kernel.

fn enable_fsverity( &self, _locked: &mut Locked<FileOpsCore>, _node: &FsNode, _current_task: &CurrentTask, _descriptor: &fsverity_descriptor, ) -> Result<(), Errno>

Marks that FS-Verity is being built. Writes fsverity descriptor and merkle tree, the latter computed by the filesystem. This should ensure there are no writable file handles. Returns EEXIST if the file was already fsverity-enabled. Returns EBUSY if this ioctl was already running on this file.

fn get_fsverity_descriptor( &self, _log_blocksize: u8, ) -> Result<fsverity_descriptor, Errno>

Read fsverity descriptor, if the node is fsverity-enabled. Else returns ENODATA.

fn internal_name(&self, _node: &FsNode) -> Option<BString>

Returns a descriptive name for this node, suitable to report to userspace in situations where the node’s path is unavailable (e.g. because it is anonymous, and has no path). If no name is returned then a default name of the form “<class:[<node_id>]” will be used.

fn node_key(&self, node: &FsNode) -> u64

The key used to identify this node in the file system’s node cache.