wok-current rev 3908

linux: no historic allocation for initramfs unlzma
author Pascal Bellard <pascal.bellard@slitaz.org>
date Sun Aug 16 20:44:30 2009 +0200 (2009-08-16)
parents 9a3ad6f0607b
children 1ef7110e0997
files linux/receipt linux/stuff/linux-unlzma-2.6.30.4.u
line diff
     1.1 --- a/linux/receipt	Sun Aug 16 19:13:58 2009 +0000
     1.2 +++ b/linux/receipt	Sun Aug 16 20:44:30 2009 +0200
     1.3 @@ -35,6 +35,7 @@
     1.4  $PACKAGE-utf8-$VERSION.u
     1.5  $PACKAGE-diff-$VERSION.u
     1.6  $PACKAGE-freeinitrd-$VERSION.u
     1.7 +$PACKAGE-unlzma-$VERSION.u
     1.8  EOT
     1.9  	make mrproper
    1.10  	cp ../stuff/$PACKAGE-$VERSION-slitaz.config .config
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/linux/stuff/linux-unlzma-2.6.30.4.u	Sun Aug 16 20:44:30 2009 +0200
     2.3 @@ -0,0 +1,222 @@
     2.4 +--- linux-2.6.30.4/init/initramfs.c
     2.5 ++++ linux-2.6.30.4/init/initramfs.c
     2.6 +@@ -425,7 +425,8 @@
     2.7 + 	return len - count;
     2.8 + }
     2.9 + 
    2.10 +-static int __init flush_buffer(void *bufv, unsigned len)
    2.11 +#define flush_buffer cpio_flush_buffer
    2.12 ++int __init flush_buffer(void *bufv, unsigned len)
    2.13 + {
    2.14 + 	char *buf = (char *) bufv;
    2.15 + 	int written;
    2.16 +
    2.17 +--- linux-2.6.30.4/lib/decompress_unlzma.c
    2.18 ++++ linux-2.6.30.4/lib/decompress_unlzma.c
    2.19 +@@ -278,6 +278,10 @@
    2.20 + 	size_t global_pos;
    2.21 + 	int(*flush)(void*, unsigned int);
    2.22 + 	struct lzma_header *header;
    2.23 ++	int is_cpio_flush;
    2.24 ++	uint8_t **buffer_index;
    2.25 ++	int next_index;
    2.26 ++	int max_index;
    2.27 + };
    2.28 + 
    2.29 + struct cstate {
    2.30 +@@ -294,6 +298,14 @@
    2.31 + static inline uint8_t INIT peek_old_byte(struct writer *wr,
    2.32 + 						uint32_t offs)
    2.33 + {
    2.34 ++	if (wr->is_cpio_flush) {
    2.35 ++		int32_t pos;
    2.36 ++		while (offs > wr->header->dict_size)
    2.37 ++			offs -= wr->header->dict_size;
    2.38 ++		pos = wr->buffer_pos - offs;
    2.39 ++		return wr->buffer_index[pos / LZMA_IOBUF_SIZE]
    2.40 ++				       [pos % LZMA_IOBUF_SIZE];
    2.41 ++	}
    2.42 + 	if (!wr->flush) {
    2.43 + 		int32_t pos;
    2.44 + 		while (offs > wr->header->dict_size)
    2.45 +@@ -311,6 +323,34 @@
    2.46 + 
    2.47 + static inline void INIT write_byte(struct writer *wr, uint8_t byte)
    2.48 + {
    2.49 ++	if (wr->is_cpio_flush) {
    2.50 ++		if (wr->buffer_pos % LZMA_IOBUF_SIZE == 0) {
    2.51 ++			// if the following large_malloc fails, the initramfs
    2.52 ++			// whould not be load with is_cpio_flush forced 0 too.
    2.53 ++			// Remember we do not allocate historic buffer.
    2.54 ++			// Let's assume it will never fail !
    2.55 ++			if (wr->next_index >= wr->max_index) {
    2.56 ++				// realloc wr->buffer_index
    2.57 ++				uint8_t **p = wr->buffer_index;
    2.58 ++				wr->buffer_index = (uint8_t **) 
    2.59 ++					large_malloc(LZMA_IOBUF_SIZE + 
    2.60 ++						    sizeof(*p) * wr->max_index);
    2.61 ++				if (wr->max_index) {
    2.62 ++					memcpy(wr->buffer_index, p,
    2.63 ++					       sizeof(*p) * wr->max_index);
    2.64 ++					free(p);
    2.65 ++				}
    2.66 ++				wr->max_index += LZMA_IOBUF_SIZE / sizeof(*p);
    2.67 ++			}
    2.68 ++			wr->buffer_index[wr->next_index++] =
    2.69 ++				(uint8_t *) large_malloc(LZMA_IOBUF_SIZE);
    2.70 ++		}
    2.71 ++		wr->buffer_index[wr->buffer_pos / LZMA_IOBUF_SIZE]
    2.72 ++				[wr->buffer_pos % LZMA_IOBUF_SIZE] =
    2.73 ++			wr->previous_byte = byte;
    2.74 ++		wr->buffer_pos++;
    2.75 ++		return;
    2.76 ++	}
    2.77 + 	wr->buffer[wr->buffer_pos++] = wr->previous_byte = byte;
    2.78 + 	if (wr->flush && wr->buffer_pos == wr->header->dict_size) {
    2.79 + 		wr->buffer_pos = 0;
    2.80 +@@ -339,6 +379,9 @@
    2.81 + 				     int pos_state, uint16_t *prob,
    2.82 + 				     int lc, uint32_t literal_pos_mask) {
    2.83 + 	int mi = 1;
    2.84 ++	static const int state[LZMA_NUM_STATES] = 
    2.85 ++		{ 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 4, 5 };
    2.86 ++
    2.87 + 	rc_update_bit_0(rc, prob);
    2.88 + 	prob = (p + LZMA_LITERAL +
    2.89 + 		(LZMA_LIT_SIZE
    2.90 +@@ -369,18 +412,13 @@
    2.91 + 		rc_get_bit(rc, prob_lit, &mi);
    2.92 + 	}
    2.93 + 	write_byte(wr, mi);
    2.94 +-	if (cst->state < 4)
    2.95 +-		cst->state = 0;
    2.96 +-	else if (cst->state < 10)
    2.97 +-		cst->state -= 3;
    2.98 +-	else
    2.99 +-		cst->state -= 6;
   2.100 ++	cst->state = state[cst->state];
   2.101 + }
   2.102 + 
   2.103 + static inline void INIT process_bit1(struct writer *wr, struct rc *rc,
   2.104 + 					    struct cstate *cst, uint16_t *p,
   2.105 + 					    int pos_state, uint16_t *prob) {
   2.106 +-  int offset;
   2.107 ++	int offset;
   2.108 + 	uint16_t *prob_len;
   2.109 + 	int num_bits;
   2.110 + 	int len;
   2.111 +@@ -396,7 +434,7 @@
   2.112 + 		prob = p + LZMA_LEN_CODER;
   2.113 + 	} else {
   2.114 + 		rc_update_bit_1(rc, prob);
   2.115 +-		prob = p + LZMA_IS_REP_G0 + cst->state;
   2.116 ++		prob += LZMA_IS_REP_G0 - LZMA_IS_REP;
   2.117 + 		if (rc_is_bit_0(rc, prob)) {
   2.118 + 			rc_update_bit_0(rc, prob);
   2.119 + 			prob = (p + LZMA_IS_REP_0_LONG
   2.120 +@@ -417,13 +455,13 @@
   2.121 + 			uint32_t distance;
   2.122 + 
   2.123 + 			rc_update_bit_1(rc, prob);
   2.124 +-			prob = p + LZMA_IS_REP_G1 + cst->state;
   2.125 ++			prob += LZMA_IS_REP_G1 - LZMA_IS_REP_G0;
   2.126 + 			if (rc_is_bit_0(rc, prob)) {
   2.127 + 				rc_update_bit_0(rc, prob);
   2.128 + 				distance = cst->rep1;
   2.129 + 			} else {
   2.130 + 				rc_update_bit_1(rc, prob);
   2.131 +-				prob = p + LZMA_IS_REP_G2 + cst->state;
   2.132 ++				prob += LZMA_IS_REP_G2 - LZMA_IS_REP_G1;
   2.133 + 				if (rc_is_bit_0(rc, prob)) {
   2.134 + 					rc_update_bit_0(rc, prob);
   2.135 + 					distance = cst->rep2;
   2.136 +@@ -451,7 +489,7 @@
   2.137 + 		num_bits = LZMA_LEN_NUM_LOW_BITS;
   2.138 + 	} else {
   2.139 + 		rc_update_bit_1(rc, prob_len);
   2.140 +-		prob_len = prob + LZMA_LEN_CHOICE_2;
   2.141 ++		prob_len += LZMA_LEN_CHOICE_2 - LZMA_LEN_CHOICE;
   2.142 + 		if (rc_is_bit_0(rc, prob_len)) {
   2.143 + 			rc_update_bit_0(rc, prob_len);
   2.144 + 			prob_len = (prob + LZMA_LEN_MID
   2.145 +@@ -461,7 +499,7 @@
   2.146 + 			num_bits = LZMA_LEN_NUM_MID_BITS;
   2.147 + 		} else {
   2.148 + 			rc_update_bit_1(rc, prob_len);
   2.149 +-			prob_len = prob + LZMA_LEN_HIGH;
   2.150 ++			prob_len += LZMA_LEN_HIGH - LZMA_LEN_CHOICE_2;
   2.151 + 			offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
   2.152 + 				  + (1 << LZMA_LEN_NUM_MID_BITS));
   2.153 + 			num_bits = LZMA_LEN_NUM_HIGH_BITS;
   2.154 +@@ -529,6 +567,7 @@
   2.155 + 			      void(*error_fn)(char *x)
   2.156 + 	)
   2.157 + {
   2.158 ++	extern int cpio_flush_buffer(void*, unsigned int);
   2.159 + 	struct lzma_header header;
   2.160 + 	int lc, pb, lp;
   2.161 + 	uint32_t pos_state_mask;
   2.162 +@@ -563,6 +602,10 @@
   2.163 + 	wr.global_pos = 0;
   2.164 + 	wr.previous_byte = 0;
   2.165 + 	wr.buffer_pos = 0;
   2.166 ++	wr.is_cpio_flush = 0;
   2.167 ++	if (flush == cpio_flush_buffer)
   2.168 ++		wr.is_cpio_flush = 1;
   2.169 ++	wr.buffer_index = NULL;
   2.170 + 
   2.171 + 	rc_init(&rc, fill, inbuf, in_len);
   2.172 + 
   2.173 +@@ -596,13 +639,13 @@
   2.174 + 	if (header.dict_size == 0)
   2.175 + 		header.dict_size = 1;
   2.176 + 
   2.177 +-	if (output)
   2.178 ++	if (output || wr.is_cpio_flush)
   2.179 + 		wr.buffer = output;
   2.180 + 	else {
   2.181 + 		wr.bufsize = MIN(header.dst_size, header.dict_size);
   2.182 + 		wr.buffer = large_malloc(wr.bufsize);
   2.183 + 	}
   2.184 +-	if (wr.buffer == NULL)
   2.185 ++	if (wr.buffer == NULL && !wr.is_cpio_flush)
   2.186 + 		goto exit_1;
   2.187 + 
   2.188 + 	num_probs = LZMA_BASE_SIZE + (LZMA_LIT_SIZE << (lc + lp));
   2.189 +@@ -612,7 +655,7 @@
   2.190 + 	num_probs = LZMA_LITERAL + (LZMA_LIT_SIZE << (lc + lp));
   2.191 + 	for (i = 0; i < num_probs; i++)
   2.192 + 		p[i] = (1 << RC_MODEL_TOTAL_BITS) >> 1;
   2.193 +-
   2.194 ++	wr.max_index = wr.next_index = 0;
   2.195 + 	rc_init_code(&rc);
   2.196 + 
   2.197 + 	while (get_pos(&wr) < header.dst_size) {
   2.198 +@@ -631,12 +674,25 @@
   2.199 + 
   2.200 + 	if (posp)
   2.201 + 		*posp = rc.ptr-rc.buffer;
   2.202 +-	if (wr.flush)
   2.203 ++	if (wr.is_cpio_flush) {
   2.204 ++		int i;
   2.205 ++		for (i = 0; i < wr.next_index -1; i++) {
   2.206 ++			wr.flush(wr.buffer_index[i], LZMA_IOBUF_SIZE);
   2.207 ++			large_free(wr.buffer_index[i]);
   2.208 ++		}
   2.209 ++		if (i < wr.next_index) {
   2.210 ++			wr.flush(wr.buffer_index[i], 
   2.211 ++				 wr.buffer_pos % LZMA_IOBUF_SIZE);
   2.212 ++			large_free(wr.buffer_index[i]);
   2.213 ++		}
   2.214 ++		large_free(wr.buffer_index);
   2.215 ++	}
   2.216 ++	else if (wr.flush)
   2.217 + 		wr.flush(wr.buffer, wr.buffer_pos);
   2.218 + 	ret = 0;
   2.219 + 	large_free(p);
   2.220 + exit_2:
   2.221 +-	if (!output)
   2.222 ++	if (!output && !wr.is_cpio_flush)
   2.223 + 		large_free(wr.buffer);
   2.224 + exit_1:
   2.225 + 	if (!buf)