| /Documentation/userspace-api/media/v4l/ |
| D | vidioc-g-edid.rst | 60 ``start_block``, ``blocks`` and ``edid`` fields, zero the ``reserved``
62 ``start_block`` and of size ``blocks`` will be placed in the memory
64 ``blocks`` * 128 bytes large (the size of one block is 128 bytes).
66 If there are fewer blocks than specified, then the driver will set
67 ``blocks`` to the actual number of blocks. If there are no EDID blocks
70 If blocks have to be retrieved from the sink, then this call will block
73 If ``start_block`` and ``blocks`` are both set to 0 when
74 :ref:`VIDIOC_G_EDID <VIDIOC_G_EDID>` is called, then the driver will set ``blocks`` to the
75 total number of available EDID blocks and it will return 0 without
76 copying any data. This is an easy way to discover how many EDID blocks
[all …]
|
| /Documentation/filesystems/ext4/ |
| D | blocks.rst | 3 Blocks title
6 ext4 allocates storage space in units of “blocks”. A block is a group of
8 integral power of 2. Blocks are in turn grouped into larger units called
11 page size (i.e. 64KiB blocks on a i386 which only has 4KiB memory
12 pages). By default a filesystem can contain 2^32 blocks; if the '64bit'
13 feature is enabled, then a filesystem can have 2^64 blocks. The location
28 * - Blocks
43 * - Blocks Per Block Group
58 * - Blocks Per File, Extents
63 * - Blocks Per File, Block Maps
[all …]
|
| D | bigalloc.rst | 10 it is desirable to be able to allocate disk blocks in units of multiple
11 blocks to reduce both fragmentation and metadata overhead. The
16 bitmap addresses a power of two number of blocks. For example, if the
20 256 4k blocks. This shrinks the total size of the block allocation
27 on, the block bitmaps track clusters, not individual blocks. This means
31 units of clusters instead of blocks” to the extent tree, though it is
|
| D | overview.rst | 8 very hard to keep each file's blocks within the same group, thereby
10 ``sb.s_blocks_per_group`` blocks, though it can also calculated as 8 \*
12 will contain 32,768 blocks, for a length of 128MiB. The number of block
19 .. include:: blocks.rst
|
| D | blockgroup.rst | 16 - Reserved GDT Blocks
20 - Data Blocks
23 - many blocks
24 - many blocks
27 - many blocks
28 - many more blocks
51 is continuous range of blocks large enough to contain
59 groups (flex\_bg). Leftover space is used for file data blocks, indirect
60 block maps, extent tree blocks, and extended attributes.
126 therefore the on-disk bitmap blocks are not initialized. This is
|
| D | about.rst | 25 ext4 divides a storage device into an array of logical blocks both to
31 logical blocks, not raw LBAs, and not 1024-byte blocks. For the sake of
35 When referenced in ``preformatted text`` blocks, ``sb`` refers to fields
|
| D | journal.rst | 23 through the journal. This means that file data blocks are /not/
28 safest. If ``data=writeback``, dirty data blocks are not flushed to the
33 mode works by logging metadata blocks to the journal. In fast commit
54 blocks. jbd2 itself does not seem to care.
144 - Descriptor. This block precedes a series of data blocks that were
155 journal to skip writing blocks that were subsequently rewritten.
190 - Total number of blocks in this journal.
244 - Limit of journal blocks per transaction. (Not used?)
248 - Limit of data blocks per transaction. (Not used?)
261 - Number of fast commit blocks in the journal.
[all …]
|
| D | allocators.rst | 8 keeping related blocks near each other reduces the amount of movement
25 Under this scheme, when a file needs more blocks to absorb file writes,
33 file's data blocks in the same block group as its inode. This cuts down
35 to learn where the file's data blocks live and then seek over to the
36 file's data blocks to begin I/O operations.
|
| D | bitmaps.rst | 6 The data block bitmap tracks the usage of data blocks within the block
17 zeros (i.e. all blocks in the group are free). However, it is not
18 necessarily the case that no blocks are in use -- if ``meta_bg`` is set,
|
| D | ifork.rst | 16 maps will be used to allocate data blocks to store the link target.
41 higher than 2^32 blocks.
47 tree. Under the old scheme, allocating a contiguous run of 1,000 blocks
63 point to the file's data blocks. The root node of the extent tree is
65 be recorded without the use of extra metadata blocks.
94 points to data blocks; otherwise, this extent node points to other
117 - This index node covers file blocks from 'block' onward.
151 - Number of blocks covered by extent. If the value of this field is <=
155 blocks, and the maximum length of an uninitialized extent is 32767.
|
| /Documentation/devicetree/bindings/sifive/ |
| D | sifive-blocks-ip-versioning.txt | 1 DT compatible string versioning for SiFive open-source IP blocks
4 strings for open-source SiFive IP blocks. HDL for these IP blocks
7 https://github.com/sifive/sifive-blocks
14 https://github.com/sifive/sifive-blocks/blob/v1.0/src/main/scala/devices/uart/UART.scala#L43
16 Until these IP blocks (or IP integration) support version
17 auto-discovery, the maintainers of these IP blocks intend to increment
19 interface to these IP blocks changes, or when the functionality of the
20 underlying IP blocks changes in a way that software should be aware of.
25 upstream sifive-blocks commits. It is expected that most drivers will
|
| /Documentation/filesystems/ |
| D | qnx6.rst | 19 concepts of blocks, inodes and directories.
28 Blocks section in Specification
31 The space in the device or file is split up into blocks. These are a fixed
49 are done by copying all modified blocks during that specific write request
57 If the level value is 0, up to 16 direct blocks can be addressed by each
61 addressing block holds up to blocksize / 4 bytes pointers to data blocks.
63 to 16 * 256 * 256 = 1048576 blocks that can be addressed by such a tree).
66 indirect addressing blocks or inodes.
75 information (total number of filesystem blocks) or by taking the highest
86 The inode structure contains pointers to the filesystem blocks which contain
[all …]
|
| D | nilfs2.rst | 67 blocks to be written to disk without making a
70 filesystem except for the updates on data blocks still
75 blocks. That means, it is guaranteed that no
84 block device when blocks are freed. This is useful
125 due to redundant move of in-use blocks.
193 of logs. Each log is composed of summary information blocks, payload
194 blocks, and an optional super root block (SR)::
209 | Summary | Payload blocks |SR|
212 The payload blocks are organized per file, and each file consists of
213 data blocks and B-tree node blocks::
[all …]
|
| D | ext2.rst | 48 resuid=n The user ID which may use the reserved blocks.
49 resgid=n The group ID which may use the reserved blocks.
77 the concepts of blocks, inodes and directories. It has space in the
84 Blocks section in Specification
87 The space in the device or file is split up into blocks. These are
89 which is decided when the filesystem is created. Smaller blocks mean
96 Blocks are clustered into block groups in order to reduce fragmentation
100 Two blocks near the start of each group are reserved for the block usage
101 bitmap and the inode usage bitmap which show which blocks and inodes
107 blocks. The block allocation algorithm attempts to allocate data blocks
[all …]
|
| D | sysv-fs.rst | 38 The superblock is only searched in the blocks 9, 15, 18, which
111 Free blocks are organized in a "free list". Maybe a misleading term,
113 the next free block. Rather, the free blocks are organized in chunks
115 to the free blocks pertaining to the next chunk; the first of these
209 * Regular file data blocks are organized as
213 - 7 direct blocks
214 - 1 indirect block (pointers to blocks)
215 - 1 double-indirect block (pointer to pointers to blocks)
219 - 10 direct blocks
220 - 1 indirect block (pointers to blocks)
[all …]
|
| D | squashfs.rst | 10 directories. Inodes in the system are very small and all blocks are packed to
100 Compressed data blocks are written to the filesystem as files are read from
115 Metadata (inodes and directories) are compressed in 8Kbyte blocks. Each
120 Inodes are packed into the metadata blocks, and are not aligned to block
121 boundaries, therefore inodes overlap compressed blocks. Inodes are identified
138 Like inodes, directories are packed into compressed metadata blocks, stored
168 Regular files consist of a sequence of contiguous compressed blocks, and/or a
179 is split into slots, caching up to eight 224 GiB files (128 KiB blocks).
189 fragment lookup table is itself stored compressed into metadata blocks.
199 stored compressed into metadata blocks. A second index table is used to
[all …]
|
| D | journalling.rst | 15 for journal stored on a raw device (in a continuous range of blocks). A
53 individual buffers (blocks). Before you start to modify a buffer you
84 on the passed nblocks param) - when it blocks it merely(!) needs to wait
94 Try to reserve the right number of blocks the first time. ;-). This will
95 be the maximum number of blocks you are going to touch in this
101 haven't reused any of the freed blocks until the transaction freeing
102 these blocks commits. If you reused these blocks and crash happens,
103 there is no way to restore the contents of the reallocated blocks at the
105 this is to mark blocks as free in internal in-memory block allocation
146 blocks.
|
| /Documentation/admin-guide/device-mapper/ |
| D | era.rst | 9 addition it keeps track of which blocks were written within a user
14 Use cases include tracking changed blocks for backup software, and
25 origin dev device holding data blocks that may change
55 <metadata block size> <#used metadata blocks>/<#total metadata blocks>
61 #used metadata blocks Number of metadata blocks used
62 #total metadata blocks Total number of metadata blocks
64 held metadata root The location, in blocks, of the metadata root
89 - Ascertain which blocks have been written since the snapshot was taken
91 - Invalidate those blocks in the caching software
99 that it uses a few 4k blocks for updating metadata::
|
| D | writecache.rst | 28 start writeback when the number of used blocks reach this
31 stop writeback when the number of used blocks drops below
34 limit the number of blocks that are in flight during
38 when the application writes this amount of blocks without
39 issuing the FLUSH request, the blocks are automatically
59 2. the number of blocks
60 3. the number of free blocks
61 4. the number of blocks under writeback
|
| D | dm-dust.rst | 10 requests on specific blocks (to emulate the behavior of a hard disk
14 "dmsetup status" displays "fail_read_on_bad_block"), reads of blocks
17 Writes of blocks in the "bad block list will result in the following:
28 messages to add arbitrary bad blocks at new locations, and the
30 configured "bad blocks" will be treated as bad, or bypassed.
86 Adding and removing bad blocks
90 enabled or disabled), bad blocks may be added or removed from the
102 These bad blocks will be stored in the "bad block list".
128 ...and writing to the bad blocks will remove the blocks from the list,
157 Counting the number of bad blocks in the bad block list
[all …]
|
| D | verity.rst | 50 The number of data blocks on the data device. Additional blocks are
55 This is the offset, in <hash_block_size>-blocks, from the start of hash_dev
79 Log corrupted blocks, but allow read operations to proceed normally.
91 Do not verify blocks that are expected to contain zeroes and always return
92 zeroes instead. This may be useful if the partition contains unused blocks
98 may be the same device where data and hash blocks reside, in which case
102 on the hash device after the hash blocks.
113 The number of encoding data blocks on the FEC device. The block size for
117 This is the offset, in <data_block_size> blocks, from the start of the
121 Verify data blocks only the first time they are read from the data device,
[all …]
|
| D | cache.rst | 56 3. A small metadata device - records which blocks are in the cache,
66 The origin is divided up into blocks of a fixed size. This block size
90 blocks should remain clean.
107 dirty blocks in a cache. Useful for decommissioning a cache or when
109 blocks, in the area of the cache being removed, to be clean. If the
110 area being removed from the cache still contains dirty blocks the resize
143 system crashes all cache blocks will be assumed dirty when restarted.
168 blocks. However, we allow this bitset to have a different block size
169 from the cache blocks. This is because we need to track the discard
187 cache dev fast device holding cached data blocks
[all …]
|
| D | dm-zoned.rst | 61 manage valid blocks (blocks written).
67 blocks.
69 2) Following the super block, a set of blocks is used to describe the
70 mapping of the logical device blocks. The mapping is done per chunk of
71 blocks, with the chunk size equal to the zoned block device size. The
77 3) A set of blocks used to store bitmaps indicating the validity of
78 blocks in the data zones follows the mapping table. A valid block is
93 the chunk. If all blocks of the sequential zone become invalid, the zone
99 information provided by the bitmaps. Valid blocks are read either from
102 accessed blocks are invalid, the read buffer is zeroed and the read
[all …]
|
| D | persistent-data.rst | 36 This provides access to the data on disk in fixed sized-blocks. There
47 This restricts access to blocks and enforces copy-on-write semantics.
62 On-disk data structures that keep track of reference counts of blocks.
63 Also acts as the allocator of new blocks. Currently two
64 implementations: a simpler one for managing blocks on a different
65 device (eg. thinly-provisioned data blocks); and one for managing
|
| /Documentation/admin-guide/ |
| D | ext4.rst | 157 blocks. If enabled older kernels cannot mount the device. This will
211 This tuning parameter controls the maximum number of inode table blocks
213 buffer cache. The default value is 32 blocks.
264 The group ID which may use the reserved blocks.
267 The user ID which may use the reserved blocks.
285 Number of filesystem blocks that mballoc will try to use for allocation
287 data disks * RAID chunk size in file system blocks.
295 Disable delayed allocation. Blocks are allocated when the data is
334 and force that any delayed allocation blocks are allocated such that at
336 blocks of the new file are forced to disk before the rename() operation
[all …]
|