| /external/v8/test/cctest/ |
| test-platform-win32.cc | 19 size_t block_size = 4 * KB; local
20 CHECK(vm->Commit(block_addr, block_size, false));
24 CHECK(vm->Uncommit(block_addr, block_size));
|
| test-platform-linux.cc | 73 size_t block_size = 4 * KB; local
74 CHECK(vm->Commit(block_addr, block_size, false));
78 CHECK(vm->Uncommit(block_addr, block_size));
|
| test-platform-nullos.cc | 73 size_t block_size = 4 * KB; local
74 CHECK(vm->Commit(block_addr, block_size, false));
78 CHECK(vm->Uncommit(block_addr, block_size));
|
| /external/bluetooth/glib/tests/ |
| slice-color.c | 58 touch_mem (guint64 block_size,
68 mema[j] = g_slice_alloc (block_size);
71 memb[j] = g_slice_alloc (block_size);
74 memc[j] = g_slice_alloc (block_size);
90 g_slice_free1 (block_size, mema[j]);
91 g_slice_free1 (block_size, memb[j]);
92 g_slice_free1 (block_size, memc[j]);
110 guint64 block_size = 512, area_size = 1024 * 1024, n_blocks, repeats = 1000000; local
113 block_size = parse_memsize (argv[1]);
117 block_size = 512
[all...] |
| base64-test.c | 11 #define BLOCK_SIZE 32
20 gsize len, decoded_len, max, input_len, block_size; local
35 block_size = MIN (BLOCK_SIZE, length - input_len);
36 len += g_base64_encode_step (data + input_len, block_size,
38 input_len += block_size;
59 int chunk_len = MIN (BLOCK_SIZE, len);
|
| /external/bluetooth/glib/glib/ |
| gslice.h | 37 gpointer g_slice_alloc (gsize block_size) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
38 gpointer g_slice_alloc0 (gsize block_size) G_GNUC_MALLOC G_GNUC_ALLOC_SIZE(1);
39 gpointer g_slice_copy (gsize block_size,
41 void g_slice_free1 (gsize block_size,
43 void g_slice_free_chain_with_offset (gsize block_size,
|
| /external/e2fsprogs/ext2ed/ |
| file_com.c | 34 file_info.global_block_offset=ptr->i_block [0]*file_system_info.block_size;
36 file_info.blocks_count=(ptr->i_size+file_system_info.block_size-1)/file_system_info.block_size;
44 low_read (file_info.buffer,file_system_info.block_size,file_info.global_block_offset);
85 file_info.global_block_offset=file_info.global_block_num*file_system_info.block_size;
86 file_info.file_offset=file_info.block_num*file_system_info.block_size;
88 low_read (file_info.buffer,file_system_info.block_size,file_info.global_block_offset);
106 if (file_info.offset_in_block+offset < file_system_info.block_size) {
133 if (offset < file_system_info.block_size) {
186 file_info.global_block_offset=file_info.global_block_num*file_system_info.block_size;
[all...] |
| inode_com.c | 39 block_num=device_offset/file_system_info.block_size;
46 entry_num=(device_offset-desc.bg_inode_table*file_system_info.block_size)/sizeof (struct ext2_inode);
87 block_num=device_offset/file_system_info.block_size;
94 entry_num=(device_offset-desc.bg_inode_table*file_system_info.block_size)/sizeof (struct ext2_inode);
129 block_num=device_offset/file_system_info.block_size;
136 entry_num=(device_offset-desc.bg_inode_table*file_system_info.block_size)/sizeof (struct ext2_inode);
295 block_num=device_offset/file_system_info.block_size;
302 entry_num=(device_offset-desc.bg_inode_table*file_system_info.block_size)/sizeof (struct ext2_inode);
377 block_num=inode_offset/file_system_info.block_size;
405 block_num=inode_offset/file_system_info.block_size;
[all...] |
| dir_com.c | 61 info_ptr->global_block_offset=ptr->i_block [0]*file_system_info.block_size;
66 info_ptr->blocks_count=(ptr->i_size+file_system_info.block_size-1)/file_system_info.block_size;
105 low_read (info.buffer,file_system_info.block_size,info.global_block_offset);
122 next = file_system_info.block_size - info.dir_entry_offset;
128 if (info.dir_entry_offset >= file_system_info.block_size) { /* We crossed a block boundary */
132 info.global_block_offset=info.global_block_num*file_system_info.block_size;
133 info.file_offset=info.block_num*file_system_info.block_size;
137 low_read (info.buffer,file_system_info.block_size,info.global_block_offset);
402 low_read (file_info.buffer,file_system_info.block_size,file_info.global_block_offset)
[all...] |
| /external/e2fsprogs/misc/ |
| badblocks.c | 80 fprintf(stderr, _("Usage: %s [-b block_size] [-i input_file] [-o output_file] [-svwnf]\n [-c blocks_at_once] [-p num_passes] [-t test_pattern [-t test_pattern [...]]]\n device [last_block [start_block]]\n"),
265 static long do_read (int dev, unsigned char * buffer, int try, int block_size,
270 set_o_direct(dev, buffer, try * block_size, current_block);
276 if (ext2fs_llseek (dev, (ext2_loff_t) current_block * block_size,
277 SEEK_SET) != (ext2_loff_t) current_block * block_size)
281 got = read (dev, buffer, try * block_size);
286 got /= block_size;
294 static long do_write (int dev, unsigned char * buffer, int try, int block_size,
299 set_o_direct(dev, buffer, try * block_size, current_block);
305 if (ext2fs_llseek (dev, (ext2_loff_t) current_block * block_size,
826 int block_size = 1024; local
[all...] |
| /external/qemu/block/ |
| cloop.c | 31 uint32_t block_size; member in struct:BDRVCloopState
70 if(read(s->fd,&s->block_size,4)<4)
72 s->block_size=be32_to_cpu(s->block_size);
93 s->uncompressed_block = qemu_malloc(s->block_size);
98 s->sectors_per_block = s->block_size/512;
117 s->zstream.avail_out = s->block_size;
122 if(ret != Z_STREAM_END || s->zstream.total_out != s->block_size)
|
| vpc.c | 93 uint32_t block_size; member in struct:vhd_dyndisk_header
122 uint32_t block_size; member in struct:BDRVVPCState
195 s->block_size = be32_to_cpu(dyndisk_header->block_size);
196 s->bitmap_size = ((s->block_size / (8 * 512)) + 511) & ~511;
213 s->bitmap_size + s->block_size;
250 pagetable_index = offset / s->block_size;
251 pageentry_index = (offset % s->block_size) / 512;
346 index = (sector_num * 512) / s->block_size;
357 s->free_data_block_offset += s->block_size + s->bitmap_size
490 size_t block_size, num_bat_entries; local
[all...] |
| /external/openssl/crypto/evp/ |
| evp_locl.h | 65 bl = ctx->cipher->block_size;\
105 #define BLOCK_CIPHER_def1(cname, nmode, mode, MODE, kstruct, nid, block_size, \
109 nid##_##nmode, block_size, key_len, iv_len, \
121 #define BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, \
124 BLOCK_CIPHER_def1(cname, cbc, cbc, CBC, kstruct, nid, block_size, key_len, \
141 #define BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, \
144 BLOCK_CIPHER_def1(cname, ecb, ecb, ECB, kstruct, nid, block_size, key_len, \
148 nid, block_size, key_len, iv_len, cbits, flags, \
150 BLOCK_CIPHER_def_cbc(cname, kstruct, nid, block_size, key_len, iv_len, flags, \
156 BLOCK_CIPHER_def_ecb(cname, kstruct, nid, block_size, key_len, flags,
[all...] |
| /external/qemu/memcheck/ |
| memcheck_malloc_map.h | 87 * block_size - Size of the block, beginning with 'address'.
94 uint32_t block_size);
|
| /external/dbus/dbus/ |
| dbus-mempool.c | 99 int block_size; /**< size of most recently allocated block */ member in struct:DBusMemPool
169 pool->block_size = pool->element_size * 8;
171 _dbus_assert ((pool->block_size %
268 pool->blocks->used_so_far == pool->block_size)
277 if (pool->block_size <= _DBUS_INT_MAX / 4) /* avoid overflow */
280 pool->block_size *= 2;
281 _dbus_assert ((pool->block_size %
285 alloc_size = sizeof (DBusMemBlock) - ELEMENT_PADDING + pool->block_size;
|
| /external/wpa_supplicant_6/wpa_supplicant/src/eap_common/ |
| eap_fast_common.c | 107 int block_size; local
109 block_size = tls_connection_get_keyblock_size(ssl_ctx, conn);
110 if (block_size < 0)
113 out = os_malloc(block_size + len);
117 if (tls_connection_prf(ssl_ctx, conn, label, 1, out, block_size + len)
119 os_memmove(out, out + block_size, len);
138 keys.server_random_len, out, block_size + len))
141 os_memmove(out, out + block_size, len);
|
| /external/e2fsprogs/lib/ext2fs/ |
| unix_io.c | 132 size = (count < 0) ? -count : count * channel->block_size;
133 location = ((ext2_loff_t) block * channel->block_size) + data->offset;
170 size = (count < 0) ? -count : count * channel->block_size;
171 location = ((ext2_loff_t) block * channel->block_size) + data->offset;
174 count, size, block, channel->block_size, (long long)location);
220 size = channel->block_size;
225 size = count * channel->block_size;
228 location = ((ext2_loff_t) block * channel->block_size) + data->offset;
267 if ((retval = ext2fs_get_mem(channel->block_size,
403 io->block_size = 1024
[all...] |
| openfs.c | 63 unsigned int block_size, io_manager manager,
66 return ext2fs_open2(name, 0, flags, superblock, block_size,
72 * Superblock and block_size can be zero to use the default size.
83 unsigned int block_size, io_manager manager,
146 block_size = fs->image_header->fs_blocksize;
159 if (!block_size) {
163 io_channel_set_blksize(fs->io, block_size);
246 if (block_size) {
247 if (block_size != fs->blocksize) {
|
| inode_io.c | 141 io->block_size = 1024;
195 channel->block_size = blksize;
211 block * channel->block_size,
215 count = (count < 0) ? -count : (count * channel->block_size);
231 block * channel->block_size,
235 count = (count < 0) ? -count : (count * channel->block_size);
|
| /bootable/recovery/mtdutils/ |
| flash_image.c | 121 size_t block_size; local
122 if (mtd_partition_info(partition, NULL, &block_size, NULL))
128 int left = block_size - headerlen;
129 while (left < 0) left += block_size;
|
| /external/wpa_supplicant/ |
| crypto_internal.c | 240 size_t block_size; member in struct:crypto_cipher::__anon6668::__anon6670
289 ctx->u.aes.block_size = key_len;
290 os_memcpy(ctx->u.aes.cbc, iv, ctx->u.aes.block_size);
323 if (len % ctx->u.aes.block_size)
325 blocks = len / ctx->u.aes.block_size;
327 for (j = 0; j < ctx->u.aes.block_size; j++)
332 ctx->u.aes.block_size);
333 plain += ctx->u.aes.block_size;
334 crypt += ctx->u.aes.block_size;
374 if (len % ctx->u.aes.block_size)
[all...] |
| sha256.c | 299 #define block_size 64 macro
305 if (md->curlen == 0 && inlen >= block_size) {
308 md->length += block_size * 8;
309 in += block_size;
310 inlen -= block_size;
312 n = MIN(inlen, (block_size - md->curlen));
317 if (md->curlen == block_size) {
320 md->length += 8 * block_size;
|
| /external/dropbear/libtomcrypt/src/headers/ |
| tomcrypt_hash.h | 341 #define HASH_PROCESS(func_name, compress_name, state_var, block_size) \
352 if (md-> state_var .curlen == 0 && inlen >= block_size) { \
356 md-> state_var .length += block_size * 8; \
357 in += block_size; \
358 inlen -= block_size; \
360 n = MIN(inlen, (block_size - md-> state_var .curlen)); \
365 if (md-> state_var .curlen == block_size) { \
369 md-> state_var .length += 8*block_size; \
|
| /external/wpa_supplicant_6/wpa_supplicant/src/crypto/ |
| sha256.c | 302 #define block_size 64 macro
308 if (md->curlen == 0 && inlen >= block_size) {
311 md->length += block_size * 8;
312 in += block_size;
313 inlen -= block_size;
315 n = MIN(inlen, (block_size - md->curlen));
320 if (md->curlen == block_size) {
323 md->length += 8 * block_size;
|
| /external/wpa_supplicant_6/wpa_supplicant/src/wps/ |
| wps_attr_build.c | 232 const size_t block_size = 16; local
238 pad_len = block_size - wpabuf_len(plain) % block_size;
242 wpabuf_put_be16(msg, block_size + wpabuf_len(plain));
244 iv = wpabuf_put(msg, block_size);
245 if (os_get_random(iv, block_size) < 0)
|
