BLOCK_SIZE
for (i = BLOCK_SIZE*(READ_OVERLAP - BLOCKS_COMPARE); i >= 0; i -= 4) {
if (memcmp(last_end - BLOCK_SIZE * BLOCKS_COMPARE, buf + i,
BLOCK_SIZE * BLOCKS_COMPARE) == 0) {
return (i + (BLOCK_SIZE * BLOCKS_COMPARE));
for (i = BLOCK_SIZE*(READ_OVERLAP - BLOCKS_COMPARE);
i < 2*READ_OVERLAP*BLOCK_SIZE; i += 4) {
if (memcmp(last_end - BLOCK_SIZE * BLOCKS_COMPARE, buf + i,
BLOCK_SIZE * BLOCKS_COMPARE) == 0) {
return (i + (BLOCK_SIZE * BLOCKS_COMPARE));
buf = (uchar_t *)my_zalloc(BLOCK_SIZE * read_burst_size);
prev = (uchar_t *)my_zalloc(BLOCK_SIZE * read_burst_size);
previous_end = buf + (blocks_to_write * BLOCK_SIZE);
off = BLOCK_SIZE * BLOCKS_COMPARE;
while ((off + (blocks_to_write*BLOCK_SIZE)) >
(blocks_to_read * BLOCK_SIZE)) {
(void) memset(&buf[off], 0, off % BLOCK_SIZE);
previous_end = buf + off + blocks_to_write * BLOCK_SIZE;
(void) memcpy(prev, buf, read_burst_size * BLOCK_SIZE);
if (h->bstr_write(h, &buf[off], blocks_to_write*BLOCK_SIZE)
mult = BLOCK_SIZE;
mult = BLOCK_SIZE;
} else if (strcasecmp(prop, BLOCK_SIZE) == 0) {
#define SBLOCK (WHICH_SUPER * BLOCK_SIZE / DEV_BSIZE) /* = 2 */
((struct minix_inode *)((int) SUPERBLOCK + BLOCK_SIZE))
((int)((int)DATABLOCK1 + BLOCK_SIZE))
return devread (fsblock * (BLOCK_SIZE / DEV_BSIZE), 0,
BLOCK_SIZE, (char *) buffer);
offset = filepos & (BLOCK_SIZE - 1);
size = BLOCK_SIZE;
devread (map * (BLOCK_SIZE / DEV_BSIZE),
#define SBLOCK (WHICH_SUPER * BLOCK_SIZE / DEV_BSIZE) /* = 2 */
off = loc & (BLOCK_SIZE - 1);
#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
#define MINIX2_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix2_inode)))
|| ! devread (0, 0, BLOCK_SIZE, (char *) FSYS_BUF)
devread (sector, 0, BLOCK_SIZE, (char *) FILE_INFO);
state->length = BLOCK_SIZE;
state->data = (void *) MALLOC(BLOCK_SIZE);
BLOCK_SIZE,
BLOCK_SIZE,
char tmp[BLOCK_SIZE];
((nblocks - 2) * BLOCK_SIZE));
((nblocks - 1) * BLOCK_SIZE));
bcopy(nlobp, tmp, BLOCK_SIZE);
bcopy(lobp, nlobp, BLOCK_SIZE);
bcopy(tmp, lobp, BLOCK_SIZE);
char tmp_pt[BLOCK_SIZE], tmp_ct[BLOCK_SIZE];
pt.cd_length = nblocks * BLOCK_SIZE;
pt.cd_uio->uio_iov[1].iov_len = BLOCK_SIZE;
ct.cd_length = nblocks * BLOCK_SIZE;
ct.cd_uio->uio_iov[1].iov_len = BLOCK_SIZE;
nlobp = (char *)(output->data + ((nblocks - 2) * BLOCK_SIZE));
lobp = (char *)(output->data + ((nblocks - 1) * BLOCK_SIZE));
bcopy(tmp_ct, nlobp, BLOCK_SIZE);
(void) memcpy(ivec->data, nlobp, BLOCK_SIZE);
char tmp_ivec[BLOCK_SIZE];
if (input->length < BLOCK_SIZE)
if (ivec->data == NULL || ivec->length != BLOCK_SIZE) {
assert(ivec->length == BLOCK_SIZE);
nblocks = (input->length + BLOCK_SIZE - 1) / BLOCK_SIZE;
partialamount = input->length % BLOCK_SIZE;
char tmp[BLOCK_SIZE];
((nblocks - 2) * BLOCK_SIZE));
((nblocks - 1) * BLOCK_SIZE));
bcopy(nlobp, tmp, BLOCK_SIZE);
bcopy(lobp, nlobp, BLOCK_SIZE);
bcopy(tmp, lobp, BLOCK_SIZE);
char tmp_pt[BLOCK_SIZE], tmp_ct[BLOCK_SIZE];
BLOCK_SIZE,
nlobp = (char *)(output->data + ((nblocks - 2) * BLOCK_SIZE));
lobp = (char *)(output->data + ((nblocks - 1) * BLOCK_SIZE));
bcopy(tmp_ct, nlobp, BLOCK_SIZE);
char local_iv_data[BLOCK_SIZE];
(void) memcpy(ivec->data, nlobp, BLOCK_SIZE);
char local_iv_data[BLOCK_SIZE];
if (input->length < BLOCK_SIZE)
if (ivec->data == NULL || ivec->length != BLOCK_SIZE) {
ASSERT(ivec->length == BLOCK_SIZE);
if (input->length < BLOCK_SIZE)
nblocks = (input->length + BLOCK_SIZE - 1) / BLOCK_SIZE;
partialamount = input->length % BLOCK_SIZE;
char orig_input[BLOCK_SIZE * 2];
char tmp[BLOCK_SIZE];
nlibp = input->data + ((nblocks - 2) * BLOCK_SIZE);
libp = input->data + ((nblocks - 1) * BLOCK_SIZE);
bcopy(nlibp, tmp, BLOCK_SIZE);
bcopy(libp, nlibp, BLOCK_SIZE);
bcopy(tmp, libp, BLOCK_SIZE);
char tmp_ivec_data[BLOCK_SIZE], tmp_input_data[BLOCK_SIZE],
tmp_output_data[BLOCK_SIZE];
Cn_1 = Cn - BLOCK_SIZE;
Cn_2 = Cn_1 - BLOCK_SIZE;
length = input->length - (BLOCK_SIZE + partialamount);
length = BLOCK_SIZE;
if (ivec->data == NULL || ivec->length != BLOCK_SIZE) {
(BLOCK_SIZE - partialamount));
ASSERT(ivec->length == BLOCK_SIZE);
(input->length - (BLOCK_SIZE + partialamount)),
input->data + ((nblocks - 2) * BLOCK_SIZE),
BLOCK_SIZE);
char tmp_ivec[BLOCK_SIZE];
if (input->length < BLOCK_SIZE)
if (ivec->data == NULL || ivec->length != BLOCK_SIZE) {
assert(ivec->length == BLOCK_SIZE);
nblocks = (input->length + BLOCK_SIZE - 1) / BLOCK_SIZE;
partialamount = input->length % BLOCK_SIZE;
nblocks = (input->length + BLOCK_SIZE - 1) / BLOCK_SIZE;
char orig_input[BLOCK_SIZE * 2];
partialamount = input->length % BLOCK_SIZE;
char tmp[BLOCK_SIZE];
nlibp = input->data + ((nblocks - 2) * BLOCK_SIZE);
libp = input->data + ((nblocks - 1) * BLOCK_SIZE);
bcopy(nlibp, tmp, BLOCK_SIZE);
bcopy(libp, nlibp, BLOCK_SIZE);
bcopy(tmp, libp, BLOCK_SIZE);
char tmp_ivec_data[BLOCK_SIZE], tmp_input_data[BLOCK_SIZE],
tmp_output_data[BLOCK_SIZE];
Cn_1 = Cn - BLOCK_SIZE;
Cn_2 = Cn_1 - BLOCK_SIZE;
length = input->length - (BLOCK_SIZE + partialamount);
length = BLOCK_SIZE;
(BLOCK_SIZE - partialamount));
(BLOCK_SIZE + partialamount)),
input->data + ((nblocks - 2) * BLOCK_SIZE),
BLOCK_SIZE);