Lines Matching +full:memory +full:- +full:mapping
1 .. SPDX-License-Identifier: GPL-2.0
62 units (generally memory pages or blocks) and looks up space mappings on
70 of mapping function calls into the filesystem across a larger amount of
78 1. Obtain a space mapping via ``->iomap_begin``
80 2. For each sub-unit of work...
82 1. Revalidate the mapping and go back to (1) above, if necessary.
89 4. Release the mapping via ``->iomap_end``, if necessary
105 -----------
127 device pre-shutdown hook from returning before other threads have
130 * **filesystem mapping lock**: This synchronization primitive is
131 internal to the filesystem and must protect the file mapping data
132 from updates while a mapping is being sampled.
138 mapping.
152 ----------------
154 The filesystem communicates to the iomap iterator the mapping of
158 .. code-block:: c
176 bytes, covered by this mapping.
179 * ``type`` describes the type of the space mapping:
184 the mapping.
192 ``->iomap_end`` function must delete the reservation.
204 Reads from this type of mapping will return zeroes to the caller.
206 mapping to MAPPED.
209 * **IOMAP_INLINE**: The file range maps to the memory buffer
211 For write operation, the ``->iomap_end`` function presumably
215 * ``flags`` describe the status of the space mapping.
216 These flags should be set by the filesystem in ``->iomap_begin``:
218 * **IOMAP_F_NEW**: The space under the mapping is newly allocated.
220 If a write fails and the mapping is a space reservation, the
230 * **IOMAP_F_SHARED**: The space under the mapping is shared.
233 * **IOMAP_F_BUFFER_HEAD**: This mapping requires the use of buffer
238 coalesced into this single mapping.
241 * **IOMAP_F_XATTR**: The mapping is for extended attribute data, not
259 inform iomap that the write I/O operation requires torn-write protection
260 based on HW-offload mechanism. They must also ensure that mapping updates
265 The filesystem should supply an ``->iomap_end`` function if it needs
269 using this mapping.
271 * **IOMAP_F_STALE**: The mapping was found to be stale.
272 iomap will call ``->iomap_end`` on this mapping and then
273 ``->iomap_begin`` to obtain a new mapping.
279 * ``bdev`` describes the block device for this mapping.
282 * ``dax_dev`` describes the DAX device for this mapping.
286 * ``inline_data`` points to a memory buffer for I/O involving
288 This value is ignored for all other mapping types.
290 * ``private`` is a pointer to `filesystem-private information
291 <https://lore.kernel.org/all/20180619164137.13720-7-hch@lst.de/>`_.
292 This value will be passed unchanged to ``->iomap_end``.
298 should not be held between ``->iomap_begin`` and ``->iomap_end``.
304 --------------------
307 structure to obtain a mapping and (optionally) to release the mapping:
309 .. code-block:: c
321 ``->iomap_begin``
324 iomap operations call ``->iomap_begin`` to obtain one file mapping for
327 This mapping should be returned through the ``iomap`` pointer.
328 The mapping must cover at least the first byte of the supplied file
334 operation-specific sections below.
342 memory-like storage.
347 This is similar in intent to ``O_NONBLOCK`` for network APIs - it is
354 single iomap mapping.
356 They need to avoid blocking memory allocations.
363 then they should return ``-EAGAIN`` as early as possible rather than
374 <https://lore.kernel.org/all/20191008071527.29304-9-hch@lst.de/>`_
377 Only pagecache and fsdax operations support reading from one mapping and
380 ``->iomap_end``
383 After the operation completes, the ``->iomap_end`` function, if present,
384 is called to signal that iomap is finished with a mapping.
386 context that were set up in ``->iomap_begin``.
391 ``flags`` will contain the same value passed to ``->iomap_begin``.
400 iomap only handles mapping and I/O.
424 ``->iomap_begin`` and ``->iomap_end`` functions to coordinate
425 access to the file space mapping information.
432 Filesystems with immutable mapping information may not require
441 For example, pagecache write operations will obtain a file mapping,
457 * Does iomap *actually* work for non-regular file data?