diff options
Diffstat (limited to 'meta/recipes-devtools/genext2fs/genext2fs-1.4.1/0003-Add-get_blkmap-and-put_blkmap.patch')
-rw-r--r-- | meta/recipes-devtools/genext2fs/genext2fs-1.4.1/0003-Add-get_blkmap-and-put_blkmap.patch | 222 |
1 files changed, 0 insertions, 222 deletions
diff --git a/meta/recipes-devtools/genext2fs/genext2fs-1.4.1/0003-Add-get_blkmap-and-put_blkmap.patch b/meta/recipes-devtools/genext2fs/genext2fs-1.4.1/0003-Add-get_blkmap-and-put_blkmap.patch deleted file mode 100644 index 1442dfaaed..0000000000 --- a/meta/recipes-devtools/genext2fs/genext2fs-1.4.1/0003-Add-get_blkmap-and-put_blkmap.patch +++ /dev/null | |||
@@ -1,222 +0,0 @@ | |||
1 | Upstream-Status: inappropriate | ||
2 | |||
3 | From c196bdeae7932c5d54bbdb7e7574d3cdae46ad02 Mon Sep 17 00:00:00 2001 | ||
4 | From: Corey Minyard <cminyard@mvista.com> | ||
5 | Date: Sat, 4 Jun 2011 22:04:24 -0500 | ||
6 | Subject: [PATCH 03/19] Add get_blkmap and put_blkmap. | ||
7 | |||
8 | Add routines for getting an putting a block map. This does not do | ||
9 | anything functional, but is getting ready for when blockmaps are | ||
10 | byteswapped when being read and written. | ||
11 | --- | ||
12 | genext2fs.c | 84 ++++++++++++++++++++++++++++++++++++++++------------------- | ||
13 | 1 files changed, 57 insertions(+), 27 deletions(-) | ||
14 | |||
15 | diff --git a/genext2fs.c b/genext2fs.c | ||
16 | index bd06369..0b5ba6f 100644 | ||
17 | --- a/genext2fs.c | ||
18 | +++ b/genext2fs.c | ||
19 | @@ -837,6 +837,36 @@ put_blk(blk_info *bi) | ||
20 | { | ||
21 | } | ||
22 | |||
23 | +// Used by get_blkmap/put_blkmap to hold information about an block map | ||
24 | +// owned by the user. | ||
25 | +typedef struct | ||
26 | +{ | ||
27 | + blk_info *bi; | ||
28 | +} blkmap_info; | ||
29 | + | ||
30 | +// Return a given block map from a filesystem. Make sure to call | ||
31 | +// put_blkmap when you are done with it. | ||
32 | +static inline uint32 * | ||
33 | +get_blkmap(filesystem *fs, uint32 blk, blkmap_info **rbmi) | ||
34 | +{ | ||
35 | + blkmap_info *bmi; | ||
36 | + uint8 *b; | ||
37 | + | ||
38 | + bmi = malloc(sizeof(*bmi)); | ||
39 | + if (!bmi) | ||
40 | + error_msg_and_die("get_blkmap: out of memory"); | ||
41 | + b = get_blk(fs, blk, &bmi->bi); | ||
42 | + *rbmi = bmi; | ||
43 | + return (uint32 *) b; | ||
44 | +} | ||
45 | + | ||
46 | +static inline void | ||
47 | +put_blkmap(blkmap_info *bmi) | ||
48 | +{ | ||
49 | + put_blk(bmi->bi); | ||
50 | + free(bmi); | ||
51 | +} | ||
52 | + | ||
53 | // Used by get_nod/put_nod to hold information about an inode owned | ||
54 | // by the user. | ||
55 | typedef struct | ||
56 | @@ -1020,12 +1050,12 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
57 | { | ||
58 | uint32 *bkref = 0; | ||
59 | uint32 bk = 0; | ||
60 | + blkmap_info *bmi1 = NULL, *bmi2 = NULL, *bmi3 = NULL; | ||
61 | uint32 *b; | ||
62 | int extend = 0, reduce = 0; | ||
63 | inode *inod; | ||
64 | nod_info *ni; | ||
65 | uint32 *iblk; | ||
66 | - blk_info *bi1 = NULL, *bi2 = NULL, *bi3 = NULL; | ||
67 | |||
68 | if(create && (*create) < 0) | ||
69 | reduce = 1; | ||
70 | @@ -1072,7 +1102,7 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
71 | iblk[bw->bpdir] = alloc_blk(fs,nod); | ||
72 | if(reduce) // free indirect block | ||
73 | free_blk(fs, iblk[bw->bpdir]); | ||
74 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
75 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
76 | bkref = &b[bw->bpind]; | ||
77 | if(extend) // allocate first block | ||
78 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
79 | @@ -1083,7 +1113,7 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
80 | else if((bw->bpdir == EXT2_IND_BLOCK) && (bw->bpind < BLOCKSIZE/4 - 1)) | ||
81 | { | ||
82 | bw->bpind++; | ||
83 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
84 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
85 | bkref = &b[bw->bpind]; | ||
86 | if(extend) // allocate block | ||
87 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
88 | @@ -1101,12 +1131,12 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
89 | iblk[bw->bpdir] = alloc_blk(fs,nod); | ||
90 | if(reduce) // free double indirect block | ||
91 | free_blk(fs, iblk[bw->bpdir]); | ||
92 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
93 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
94 | if(extend) // allocate first indirect block | ||
95 | b[bw->bpind] = alloc_blk(fs,nod); | ||
96 | if(reduce) // free firstindirect block | ||
97 | free_blk(fs, b[bw->bpind]); | ||
98 | - b = (uint32*)get_blk(fs, b[bw->bpind], &bi1); | ||
99 | + b = get_blkmap(fs, b[bw->bpind], &bmi2); | ||
100 | bkref = &b[bw->bpdind]; | ||
101 | if(extend) // allocate first block | ||
102 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
103 | @@ -1117,8 +1147,8 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
104 | else if((bw->bpdir == EXT2_DIND_BLOCK) && (bw->bpdind < BLOCKSIZE/4 - 1)) | ||
105 | { | ||
106 | bw->bpdind++; | ||
107 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
108 | - b = (uint32*)get_blk(fs, b[bw->bpind], &bi2); | ||
109 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
110 | + b = get_blkmap(fs, b[bw->bpind], &bmi2); | ||
111 | bkref = &b[bw->bpdind]; | ||
112 | if(extend) // allocate block | ||
113 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
114 | @@ -1131,12 +1161,12 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
115 | bw->bnum++; | ||
116 | bw->bpdind = 0; | ||
117 | bw->bpind++; | ||
118 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
119 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
120 | if(extend) // allocate indirect block | ||
121 | b[bw->bpind] = alloc_blk(fs,nod); | ||
122 | if(reduce) // free indirect block | ||
123 | free_blk(fs, b[bw->bpind]); | ||
124 | - b = (uint32*)get_blk(fs, b[bw->bpind], &bi2); | ||
125 | + b = get_blkmap(fs, b[bw->bpind], &bmi2); | ||
126 | bkref = &b[bw->bpdind]; | ||
127 | if(extend) // allocate first block | ||
128 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
129 | @@ -1159,17 +1189,17 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
130 | iblk[bw->bpdir] = alloc_blk(fs,nod); | ||
131 | if(reduce) // free triple indirect block | ||
132 | free_blk(fs, iblk[bw->bpdir]); | ||
133 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
134 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
135 | if(extend) // allocate first double indirect block | ||
136 | b[bw->bpind] = alloc_blk(fs,nod); | ||
137 | if(reduce) // free first double indirect block | ||
138 | free_blk(fs, b[bw->bpind]); | ||
139 | - b = (uint32*)get_blk(fs, b[bw->bpind], &bi2); | ||
140 | + b = get_blkmap(fs, b[bw->bpind], &bmi2); | ||
141 | if(extend) // allocate first indirect block | ||
142 | b[bw->bpdind] = alloc_blk(fs,nod); | ||
143 | if(reduce) // free first indirect block | ||
144 | free_blk(fs, b[bw->bpind]); | ||
145 | - b = (uint32*)get_blk(fs, b[bw->bpdind], &bi3); | ||
146 | + b = get_blkmap(fs, b[bw->bpdind], &bmi3); | ||
147 | bkref = &b[bw->bptind]; | ||
148 | if(extend) // allocate first data block | ||
149 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
150 | @@ -1183,9 +1213,9 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
151 | (bw->bptind < BLOCKSIZE/4 -1) ) | ||
152 | { | ||
153 | bw->bptind++; | ||
154 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
155 | - b = (uint32*)get_blk(fs, b[bw->bpind], &bi2); | ||
156 | - b = (uint32*)get_blk(fs, b[bw->bpdind], &bi3); | ||
157 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
158 | + b = get_blkmap(fs, b[bw->bpind], &bmi2); | ||
159 | + b = get_blkmap(fs, b[bw->bpdind], &bmi3); | ||
160 | bkref = &b[bw->bptind]; | ||
161 | if(extend) // allocate data block | ||
162 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
163 | @@ -1202,13 +1232,13 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
164 | bw->bnum++; | ||
165 | bw->bptind = 0; | ||
166 | bw->bpdind++; | ||
167 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
168 | - b = (uint32*)get_blk(fs, b[bw->bpind], &bi2); | ||
169 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
170 | + b = get_blkmap(fs, b[bw->bpind], &bmi2); | ||
171 | if(extend) // allocate single indirect block | ||
172 | b[bw->bpdind] = alloc_blk(fs,nod); | ||
173 | if(reduce) // free indirect block | ||
174 | free_blk(fs, b[bw->bpind]); | ||
175 | - b = (uint32*)get_blk(fs, b[bw->bpdind], &bi3); | ||
176 | + b = get_blkmap(fs, b[bw->bpdind], &bmi3); | ||
177 | bkref = &b[bw->bptind]; | ||
178 | if(extend) // allocate first data block | ||
179 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
180 | @@ -1225,17 +1255,17 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
181 | bw->bpdind = 0; | ||
182 | bw->bptind = 0; | ||
183 | bw->bpind++; | ||
184 | - b = (uint32*)get_blk(fs, iblk[bw->bpdir], &bi1); | ||
185 | + b = get_blkmap(fs, iblk[bw->bpdir], &bmi1); | ||
186 | if(extend) // allocate double indirect block | ||
187 | b[bw->bpind] = alloc_blk(fs,nod); | ||
188 | if(reduce) // free double indirect block | ||
189 | free_blk(fs, b[bw->bpind]); | ||
190 | - b = (uint32*)get_blk(fs, b[bw->bpind], &bi2); | ||
191 | + b = get_blkmap(fs, b[bw->bpind], &bmi2); | ||
192 | if(extend) // allocate single indirect block | ||
193 | b[bw->bpdind] = alloc_blk(fs,nod); | ||
194 | if(reduce) // free indirect block | ||
195 | free_blk(fs, b[bw->bpind]); | ||
196 | - b = (uint32*)get_blk(fs, b[bw->bpdind], &bi3); | ||
197 | + b = get_blkmap(fs, b[bw->bpdind], &bmi3); | ||
198 | bkref = &b[bw->bptind]; | ||
199 | if(extend) // allocate first block | ||
200 | *bkref = hole ? 0 : alloc_blk(fs,nod); | ||
201 | @@ -1247,12 +1277,12 @@ walk_bw(filesystem *fs, uint32 nod, blockwalker *bw, int32 *create, uint32 hole) | ||
202 | /* End change for walking triple indirection */ | ||
203 | |||
204 | bk = *bkref; | ||
205 | - if (bi3) | ||
206 | - put_blk(bi3); | ||
207 | - if (bi2) | ||
208 | - put_blk(bi2); | ||
209 | - if (bi1) | ||
210 | - put_blk(bi1); | ||
211 | + if (bmi3) | ||
212 | + put_blkmap(bmi3); | ||
213 | + if (bmi2) | ||
214 | + put_blkmap(bmi2); | ||
215 | + if (bmi1) | ||
216 | + put_blkmap(bmi1); | ||
217 | |||
218 | if(bk) | ||
219 | { | ||
220 | -- | ||
221 | 1.7.4.1 | ||
222 | |||