121 	struct compress_state *const S = &global_state;  in vndcompress()  local
124 	S->image_fd = -1;  in vndcompress()
125 	S->cloop2_fd = -1;  in vndcompress()
133 	compress_init(argc, argv, O, S);  in vndcompress()
134 	assert(MIN_BLOCKSIZE <= S->blocksize);  in vndcompress()
135 	assert(S->blocksize <= MAX_BLOCKSIZE);  in vndcompress()
146 	void *const uncompbuf = malloc(S->blocksize);  in vndcompress()
152 	void *const compbuf = malloc(2 * (size_t)S->blocksize);  in vndcompress()
161 	while (S->blkno < S->n_blocks) {  in vndcompress()
163 		compress_progress(S);  in vndcompress()
166 		if ((0 < S->end_block) && (S->end_block <= S->blkno))  in vndcompress()
170 		compress_maybe_checkpoint(S);  in vndcompress()
171 		offtab_prepare_put(&S->offtab, (S->blkno + 1));  in vndcompress()
174 		const uint32_t readsize = (S->blkno == S->n_full_blocks?  in vndcompress()
175 		    (S->size % S->blocksize) : S->blocksize);  in vndcompress()
177 		assert(readsize <= S->blocksize);  in vndcompress()
183 		assert(S->offset <= MIN(UINT64_MAX, OFF_MAX));  in vndcompress()
184 		if (!ADD_OK(uint64_t, S->offset, 2*(uintmax_t)readsize) ||  in vndcompress()
185 		    !ADD_OK(off_t, S->offset, 2*(uintmax_t)readsize))  in vndcompress()
187 			    S->blkno, (uintmax_t)S->offset,  in vndcompress()
192 		    compress_block(S->image_fd, S->cloop2_fd, S->blkno,  in vndcompress()
193 			S->blocksize, readsize, uncompbuf, compbuf);  in vndcompress()
201 		assert(ADD_OK(uint32_t, S->blkno, 1));  in vndcompress()
202 		assert(ADD_OK(uint64_t, S->offset, complen));  in vndcompress()
203 		assert(ADD_OK(off_t, (off_t)S->offset, (off_t)complen));  in vndcompress()
204 		assert((S->blkno + 1) < S->n_offsets);  in vndcompress()
208 		S->blkno += 1;					/* (a) */  in vndcompress()
209 		S->offset += complen;				/* (b) */  in vndcompress()
210 		offtab_put(&S->offtab, S->blkno, S->offset);	/* (c) */  in vndcompress()
216 	assert(S->blkno == S->n_blocks);  in vndcompress()
217 	assert((S->blkno + 1) == S->n_offsets);  in vndcompress()
220 	const uint32_t n_extra = (S->offset % DEV_BSIZE);  in vndcompress()
225 		const ssize_t n_written = write(S->cloop2_fd, compbuf,  in vndcompress()
236 		assert(ADD_OK(uint64_t, S->offset, n_padding));  in vndcompress()
237 		assert(ADD_OK(off_t, (off_t)S->offset, (off_t)n_padding));  in vndcompress()
241 		S->offset += n_padding;  in vndcompress()
248 	assert(S->offset <= OFF_MAX);  in vndcompress()
249 	assert((off_t)S->offset == lseek(S->cloop2_fd, 0, SEEK_CUR));  in vndcompress()
250 	compress_checkpoint(S);  in vndcompress()
257 	compress_exit(S);  in vndcompress()
299 	struct compress_state *const S = &global_state;  in info_signal_handler()  local
303 	if (!S->initialized) {  in info_signal_handler()
309 	assert(S->blocksize > 0);  in info_signal_handler()
311 	const uint64_t nread = ((uint64_t)S->blkno * (uint64_t)S->blocksize);  in info_signal_handler()
313 	assert(S->n_blocks > 0);  in info_signal_handler()
317 	const uint64_t nwritten = (S->offset <= (CLOOP2_OFFSET_TABLE_OFFSET +  in info_signal_handler()
318 		((uint64_t)S->n_blocks * sizeof(uint64_t)))?  in info_signal_handler()
319 	    0 : S->offset);  in info_signal_handler()
329 	assert(S->n_checkpointed_blocks <= MAX_N_BLOCKS);  in info_signal_handler()
330 	assert(S->blocksize <= MAX_BLOCKSIZE);  in info_signal_handler()
336 	    ((uint64_t)S->n_checkpointed_blocks * (uint64_t)S->blocksize));  in info_signal_handler()
355 	struct compress_state *const S = &global_state;  in checkpoint_signal_handler()  local
358 	if (!S->initialized) {  in checkpoint_signal_handler()
363 	assert(S->image_fd >= 0);  in checkpoint_signal_handler()
364 	assert(S->cloop2_fd >= 0);  in checkpoint_signal_handler()
367 	assert(S->blkno <= MAX_N_BLOCKS);  in checkpoint_signal_handler()
368 	assert(S->blocksize <= MAX_BLOCKSIZE);  in checkpoint_signal_handler()
371 	    ((uint64_t)S->blkno * (uint64_t)S->blocksize));  in checkpoint_signal_handler()
372 	compress_checkpoint(S);  in checkpoint_signal_handler()
385 compress_progress(struct compress_state *S __unused)  in compress_progress()
394     struct compress_state *S)  in compress_init()  argument
415 		S->blocksize = O->blocksize;  in compress_init()
417 		S->blocksize = (argc == 2? DEF_BLOCKSIZE :  in compress_init()
424 	if ((S->blocksize % DEV_BSIZE) != 0)  in compress_init()
427 		    S->blocksize, (uint32_t)DEV_BSIZE);  in compress_init()
428 	assert(MIN_BLOCKSIZE <= S->blocksize);  in compress_init()
429 	assert((S->blocksize % DEV_BSIZE) == 0);  in compress_init()
430 	assert(S->blocksize <= MAX_BLOCKSIZE);  in compress_init()
433 	S->end_block = (ISSET(O->flags, FLAG_p)? O->end_block : 0);  in compress_init()
436 	S->checkpoint_blocks =  in compress_init()
440 	S->image_fd = open(image_pathname, O_RDONLY);  in compress_init()
441 	if (S->image_fd == -1)  in compress_init()
451 	S->cloop2_fd = open(cloop2_pathname, oflags, 0777);  in compress_init()
452 	if (S->cloop2_fd == -1)  in compress_init()
457 		S->size = O->length;  in compress_init()
461 		if (fstat(S->image_fd, &st) == -1)  in compress_init()
468 		S->size = st.st_size;  in compress_init()
470 	assert(S->size <= OFF_MAX);  in compress_init()
474 	assert(0 < S->blocksize);  in compress_init()
475 	if (TOOMANY(off_t, (off_t)S->size, (off_t)S->blocksize,  in compress_init()
478 		    S->blocksize, S->size);  in compress_init()
480 	S->n_full_blocks = S->size/S->blocksize;  in compress_init()
481 	S->n_blocks = HOWMANY(S->size, S->blocksize);  in compress_init()
482 	assert(S->n_full_blocks <= S->n_blocks);  in compress_init()
483 	assert(S->n_blocks <= MAX_N_BLOCKS);  in compress_init()
491 	S->n_offsets = (S->n_blocks + 1);  in compress_init()
495 	offtab_init(&S->offtab, S->n_offsets, window_size, S->cloop2_fd,  in compress_init()
500 		if (compress_restart(S)) {  in compress_init()
509 			if (ftruncate(S->cloop2_fd, S->offset) == -1)  in compress_init()
520 			if (ftruncate(S->cloop2_fd, 0) == -1)  in compress_init()
522 			if (lseek(S->cloop2_fd, 0, SEEK_SET) == -1)  in compress_init()
526 			if (S->blkno != 0) {  in compress_init()
527 				if (lseek(S->image_fd, 0, SEEK_SET) == -1)  in compress_init()
536 	const ssize_t h_written = write(S->cloop2_fd, &zero_header,  in compress_init()
546 	offtab_reset_write(&S->offtab);  in compress_init()
549 	S->blkno = 0;  in compress_init()
550 	S->offset = (sizeof(struct cloop2_header) +  in compress_init()
551 	    ((uint64_t)S->n_offsets * sizeof(uint64_t)));  in compress_init()
552 	S->n_checkpointed_blocks = 0;  in compress_init()
555 	S->initialized = 1;  in compress_init()
569 compress_restart(struct compress_state *S)  in compress_restart()  argument
576 	const ssize_t h_read = read_block(S->cloop2_fd, &header,  in compress_restart()
597 	if (be32toh(header.cl2h_blocksize) != S->blocksize) {  in compress_restart()
600 		    be32toh(header.cl2h_blocksize), S->blocksize);  in compress_restart()
603 	if (be32toh(header.cl2h_n_blocks) != S->n_blocks) {  in compress_restart()
606 		    be32toh(header.cl2h_n_blocks), S->n_blocks);  in compress_restart()
611 	if (!offtab_reset_read(&S->offtab, &warn, &warnx))  in compress_restart()
613 	if (!offtab_prepare_get(&S->offtab, 0))  in compress_restart()
615 	const uint64_t first_offset = offtab_get(&S->offtab, 0);  in compress_restart()
620 	    ((uint64_t)S->n_offsets * sizeof(uint64_t));  in compress_restart()
631 	for (blkno = 0; blkno < S->n_blocks; blkno++) {  in compress_restart()
632 		if (!offtab_prepare_get(&S->offtab, blkno))  in compress_restart()
634 		const uint64_t offset = offtab_get(&S->offtab, blkno);  in compress_restart()
648 			if ((2 * (size_t)S->blocksize) <= (end - start)) {  in compress_restart()
666 	if (blkno < S->n_blocks) {  in compress_restart()
669 		for (nblkno = blkno; nblkno < S->n_blocks; nblkno++) {  in compress_restart()
670 			if (!offtab_prepare_get(&S->offtab, nblkno))  in compress_restart()
672 			const uint64_t offset = offtab_get(&S->offtab, nblkno);  in compress_restart()
693 	if (lseek(S->cloop2_fd, last_offset, SEEK_SET) == -1) {  in compress_restart()
699 	if (!offtab_transmogrify_read_to_write(&S->offtab, blkno))  in compress_restart()
708 	assert(S->size <= OFF_MAX);  in compress_restart()
709 	assert(blkno <= (S->size / S->blocksize));  in compress_restart()
710 	const off_t restart_position = ((off_t)blkno * (off_t)S->blocksize);  in compress_restart()
712 	assert(restart_position <= (off_t)S->size);  in compress_restart()
713 	if (lseek(S->image_fd, restart_position, SEEK_SET) == -1) {  in compress_restart()
726 			const ssize_t n_read = read_block(S->image_fd, buffer,  in compress_restart()
746 	S->blkno = blkno;  in compress_restart()
747 	S->offset = last_offset;  in compress_restart()
748 	S->n_checkpointed_blocks = blkno;  in compress_restart()
751 	S->initialized = 1;  in compress_restart()
807 compress_maybe_checkpoint(struct compress_state *S)  in compress_maybe_checkpoint()  argument
810 	if ((0 < S->checkpoint_blocks) && (0 < S->blkno) &&  in compress_maybe_checkpoint()
811 	    ((S->blkno % S->checkpoint_blocks) == 0)) {  in compress_maybe_checkpoint()
812 		assert(S->offset <= OFF_MAX);  in compress_maybe_checkpoint()
813 		assert((off_t)S->offset == lseek(S->cloop2_fd, 0, SEEK_CUR));  in compress_maybe_checkpoint()
814 		compress_checkpoint(S);  in compress_maybe_checkpoint()
841 compress_checkpoint(struct compress_state *S)  in compress_checkpoint()  argument
844 	assert(S->blkno < S->n_offsets);  in compress_checkpoint()
845 	const uint32_t n_offsets = (S->blkno + 1);  in compress_checkpoint()
846 	assert(n_offsets <= S->n_offsets);  in compress_checkpoint()
848 	assert(S->offset <= OFF_MAX);  in compress_checkpoint()
849 	assert((off_t)S->offset <= lseek(S->cloop2_fd, 0, SEEK_CUR));  in compress_checkpoint()
852 	if (fsync_range(S->cloop2_fd, (FFILESYNC | FDISKSYNC), 0, S->offset)  in compress_checkpoint()
857 	offtab_checkpoint(&S->offtab, n_offsets,  in compress_checkpoint()
858 	    (S->n_checkpointed_blocks == 0? OFFTAB_CHECKPOINT_SYNC : 0));  in compress_checkpoint()
869 	if (S->n_checkpointed_blocks == 0) {  in compress_checkpoint()
877 		header.cl2h_blocksize = htobe32(S->blocksize);  in compress_checkpoint()
878 		header.cl2h_n_blocks = htobe32(S->n_blocks);  in compress_checkpoint()
881 		const ssize_t h_written = pwrite(S->cloop2_fd, &header,  in compress_checkpoint()
895 	S->n_checkpointed_blocks = S->blkno;  in compress_checkpoint()
904 compress_exit(struct compress_state *S)  in compress_exit()  argument
908 	offtab_destroy(&S->offtab);  in compress_exit()
911 	if (close(S->cloop2_fd) == -1)  in compress_exit()
913 	if (close(S->image_fd) == -1)  in compress_exit()