| /linux/Documentation/userspace-api/media/v4l/ |
| H A 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 …]
|
| /linux/Documentation/admin-guide/device-mapper/ |
| H A D | writecache.rst | 27 start writeback when the number of used blocks reach this
30 stop writeback when the number of used blocks drops below
33 limit the number of blocks that are in flight during
37 when the application writes this amount of blocks without
38 issuing the FLUSH request, the blocks are automatically
58 new writes (however, writes to already cached blocks are
63 blocks drops to zero, userspace can unload the
80 2. the number of blocks
81 3. the number of free blocks
82 4. the number of blocks under writeback
[all …]
|
| H A 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 …]
|
| H A 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::
|
| H A 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 …]
|
| H A 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 …]
|
| /linux/Documentation/filesystems/ext4/ |
| H A 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 …]
|
| /linux/fs/jffs2/ |
| H A D | jffs2_fs_sb.h | 80 /* Number of free blocks there must be before we... */
86 /* Number of 'very dirty' blocks before we trigger immediate GC */
92 struct jffs2_eraseblock *blocks; /* The whole array of blocks. Used for getting blocks member
93 * from the offset (blocks[ofs / sector_size]) */
98 struct list_head clean_list; /* Blocks 100% full of clean data */
99 struct list_head very_dirty_list; /* Blocks with lots of dirty space */
100 struct list_head dirty_list; /* Blocks with some dirty space */
101 struct list_head erasable_list; /* Blocks which are completely dirty, and need erasing */
102 …struct list_head erasable_pending_wbuf_list; /* Blocks which need erasing but only after the curre…
103 struct list_head erasing_list; /* Blocks which are currently erasing */
[all …]
|
| /linux/Documentation/filesystems/ |
| H A 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 …]
|
| /linux/arch/arm64/crypto/ |
| H A D | aes-neonbs-glue.c | 31 int rounds, int blocks);
33 int rounds, int blocks);
36 int rounds, int blocks, u8 iv[]);
39 int rounds, int blocks, u8 iv[]);
42 int rounds, int blocks, u8 iv[]);
44 int rounds, int blocks, u8 iv[]);
88 int rounds, int blocks)) in __ecb_crypt() argument
98 unsigned int blocks = walk.nbytes / AES_BLOCK_SIZE; in __ecb_crypt() local
101 blocks = round_down(blocks, in __ecb_crypt()
106 ctx->rounds, blocks); in __ecb_crypt()
[all …]
|
| /linux/drivers/accel/habanalabs/common/ |
| H A D | security.c | 44 * @pb_blocks: blocks array
45 * @array_size: blocks array size
98 * @pb_blocks: blocks array
100 * @array_size: blocks array size
127 * @pb_blocks: blocks array
129 * @array_size: blocks array size
163 * @pb_blocks: blocks array
165 * @blocks_array_size: blocks array size
193 * @pb_blocks: blocks array
195 * @blocks_array_size: blocks array size
[all …]
|
| H A D | security.h | 15 /* special blocks */
29 * @major: number of major blocks of particular type.
30 * @minor: number of minor blocks of particular type.
31 * @sub_minor: number of sub minor blocks of particular type.
32 * @major_offset: address gap between 2 consecutive major blocks of particular type,
34 * @minor_offset: address gap between 2 consecutive minor blocks of particular type,
36 * @sub_minor_offset: address gap between 2 consecutive sub_minor blocks of particular
39 * e.g., in Gaudi2, NIC_UMR blocks can be interpreted as:
42 * 2 blocks with different minor numbers (i.e. 0 to 1). Again, for each minor
43 * number there are 15 blocks with different sub_minor numbers (i.e. 0 to 14).
[all …]
|
| /linux/drivers/mtd/ |
| H A D | rfd_ftl.c | 88 struct block *blocks; member
95 struct block *block = &part->blocks[block_no]; in build_block_map()
188 part->blocks = kzalloc_objs(struct block, part->total_blocks); in scan_header()
189 if (!part->blocks) in scan_header()
234 kfree(part->blocks); in scan_header()
276 erase->addr = part->blocks[block].offset; in erase_block()
279 part->blocks[block].state = BLOCK_ERASING; in erase_block()
280 part->blocks[block].free_sectors = 0; in erase_block()
287 part->blocks[block].state = BLOCK_FAILED; in erase_block()
288 part->blocks[block].free_sectors = 0; in erase_block()
[all …]
|
| /linux/Documentation/devicetree/bindings/sifive/ |
| H A 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
|
| /linux/fs/jfs/ |
| H A D | jfs_extent.c | 82 /* This blocks if we are low on resources */ in extAlloc()
105 * extent if we can allocate the blocks immediately in extAlloc()
116 /* allocate the disk blocks for the extent. initially, extBalloc() in extAlloc()
117 * will try to allocate disk blocks for the requested size (xlen). in extAlloc()
118 * if this fails (xlen contiguous free blocks not available), it'll in extAlloc()
119 * try to allocate a smaller number of blocks (producing a smaller in extAlloc()
120 * extent), with this smaller number of blocks consisting of the in extAlloc()
121 * requested number of blocks rounded down to the next smaller in extAlloc()
123 * and retry the allocation until the number of blocks to allocate in extAlloc()
124 * is smaller than the number of blocks per page. in extAlloc()
[all …]
|
| /linux/fs/xfs/libxfs/ |
| H A D | xfs_btree_staging.c | 27 * initializing new btree blocks and filling them with records or key/ptr
184 * height of and the number of blocks needed to construct the btree. See the
188 * In step four, the caller must allocate xfs_btree_bload.nr_blocks blocks and
190 * blocks to be allocated beforehand to avoid ENOSPC failures midway through a
197 * is responsible for cleaning up the previous btree blocks, if any.
205 * is the number of blocks in the next lower level of the tree. For each
210 * The number of blocks for the level is defined to be:
212 * blocks = floor(nr_items / desired)
218 * npb = nr_items / blocks
220 * Some of the leftmost blocks in the level will contain one extra record as
[all …]
|
| /linux/arch/x86/crypto/ |
| H A D | ecb_cbc_helpers.h | 32 #define ECB_WALK_ADVANCE(blocks) do { \ argument
33 dst += (blocks) * __bsize; \
34 src += (blocks) * __bsize; \
35 nbytes -= (blocks) * __bsize; \
38 #define ECB_BLOCK(blocks, func) do { \ argument
39 const int __blocks = (blocks); \
46 ECB_WALK_ADVANCE(blocks); \
61 #define CBC_DEC_BLOCK(blocks, func) do { \ argument
62 const int __blocks = (blocks); \
68 const u8 *__iv = src + ((blocks) - 1) * __bsize; \
[all …]
|
| /linux/fs/xfs/scrub/ |
| H A D | alloc_repair.c | 61 * record all visited rmap btree blocks and all blocks owned by the AGFL.
64 * expression identifies possible former bnobt/cntbt blocks:
66 * (OWN_AG blocks) & ~(rmapbt blocks | agfl blocks);
78 * bnobt/cntbt blocks. The xagb_bitmap_disunion operation modifies its first
82 * reservation and used to format new btree blocks. The remaining records are
91 /* Blocks owned by the rmapbt or the agfl. */
94 /* All OWN_AG blocks. */
123 /* Number of free blocks in this AG. */
232 /* Record all the OWN_AG blocks... */ in xrep_abt_walk_rmap()
240 /* ...and all the rmapbt blocks... */ in xrep_abt_walk_rmap()
[all …]
|
| H A D | reap.c | 56 * Disposal of Blocks from Old Metadata
59 * to dispose of the blocks that (we think) the old btree was using.
62 * blocks with the same rmap owner that are owned by another data structure
64 * remaining in bitmap are the old btree's blocks.
67 * blocks on disk. The rmap data can tell us if there are multiple owners, so
74 * will be rebuilt (atop different blocks), thereby removing all the cross
103 * For AG blocks, this is reverse mapping owner and
110 /* For file blocks, this is the inode and fork. */
246 * given a quantity of fs blocks.
296 * Avoid invalidating AG headers and post-EOFS blocks because we never in xreap_agextent_binval()
[all …]
|
| /linux/tools/testing/selftests/vDSO/ |
| H A D | vdso_test_chacha.c | 85 enum { TRIALS = 1000, BLOCKS = 128, BLOCK_SIZE = 64 }; in main() enumerator
87 uint8_t output1[BLOCK_SIZE * BLOCKS], output2[BLOCK_SIZE * BLOCKS]; in main()
98 reference_chacha20_blocks(output1, key, counter1, BLOCKS); in main()
99 for (unsigned int split = 0; split < BLOCKS; ++split) { in main()
104 __arch_chacha20_blocks_nostack(output2 + split * BLOCK_SIZE, key, counter2, BLOCKS - split); in main()
112 counter1[0] = (uint32_t)-BLOCKS + 2; in main()
114 counter2[0] = (uint32_t)-BLOCKS + 2; in main()
116 reference_chacha20_blocks(output1, key, counter1, BLOCKS); in main()
117 __arch_chacha20_blocks_nostack(output2, key, counter2, BLOCKS); in main()
123 reference_chacha20_blocks(output1, key, counter1, BLOCKS); in main()
[all …]
|
| /linux/fs/ext4/ |
| H A D | ext4_jbd2.h | 21 /* Define the number of blocks we need to account to a transaction to
25 * indirection blocks, the group and superblock summaries, and the data
53 * Define the number of metadata blocks we need to account to modify data.
55 * This include super block, inode block, quota blocks and xattr blocks
79 * directory. For each new index block, we need 4 blocks (old index
87 /* Amount of blocks needed for quota update - we know that the structure was
90 /* Amount of blocks needed for quota insert/delete - we do some block writes
181 unsigned int line, int type, int blocks,
206 int blocks) in ext4_free_metadata_revoke_credits() argument
209 return blocks * EXT4_SB(sb)->s_cluster_ratio; in ext4_free_metadata_revoke_credits()
[all …]
|
| /linux/drivers/md/dm-vdo/ |
| H A D | recovery-journal.h | 33 * The journal consists of a set of on-disk blocks arranged as a circular log with monotonically
36 * half-open interval containing the active blocks. 'active' is the number of the block actively
40 * The journal also contains a set of in-memory blocks which are used to buffer up entries until
41 * they can be committed. In general the number of in-memory blocks ('tail_buffer_count') will be
45 * to accumulate entries while a partial commit of the block is in progress. In-memory blocks are
46 * kept on two lists. Free blocks live on the 'free_tail_blocks' list. When a block becomes active
62 * counters are used as locks to prevent premature reaping of journal blocks. Each time a new
65 * prevents blocks from being reaped while they are still being updated. The counter is also
67 * is updated in memory for that request. This prevents blocks from being reaped while their VIOs
184 /* Unused in-memory journal blocks */
[all …]
|
| H A D | statistics.h | 16 /* The total number of slabs from which blocks may be allocated */
18 /* The total number of slabs from which blocks have ever been allocated */
25 * Counters for tracking the number of items written (blocks, requests, etc.)
48 /* Write/Commit totals for journal blocks */
49 struct commit_statistics blocks; member
56 /* Number of blocks containing compressed items written since startup */
78 /* Number of blocks written */
84 /* Number of reference blocks written */
201 /* Number of blocks used for data */
203 /* Number of blocks used for VDO metadata */
[all …]
|
| /linux/fs/befs/ |
| H A D | datastream.c | 161 * befs_count_blocks - blocks used by a file
165 * Counts the number of fs blocks that the file represented by
174 befs_blocknr_t blocks; in befs_count_blocks() local
175 befs_blocknr_t datablocks; /* File data blocks */ in befs_count_blocks()
176 befs_blocknr_t metablocks; /* FS metadata blocks */ in befs_count_blocks()
192 * Double indir block, plus all the indirect blocks it maps. in befs_count_blocks()
194 * BEFS_DBLINDIR_BRUN_LEN blocks long. Therefore, we know in befs_count_blocks()
196 * and from that we know how many indirect blocks it takes to in befs_count_blocks()
197 * map them. We assume that the indirect blocks are also in befs_count_blocks()
198 * BEFS_DBLINDIR_BRUN_LEN blocks long. in befs_count_blocks()
[all …]
|
| /linux/fs/omfs/ |
| H A D | omfs_fs.h | 27 __be64 s_num_blocks; /* total number of FS blocks */
30 __be32 s_mirrors; /* # of mirrors of system blocks */
31 __be32 s_sys_blocksize; /* size of non-data blocks */
49 __be64 r_num_blocks; /* total number of FS blocks */
53 __be32 r_clustersize; /* size allocated for data blocks */
54 __be64 r_mirrors; /* # of mirrors of system blocks */
72 __be64 e_cluster; /* start location of a set of blocks */
73 __be64 e_blocks; /* number of blocks after e_cluster */
|