summaryrefslogtreecommitdiffstats
path: root/meta/recipes-devtools/genext2fs/genext2fs-1.4.1/0003-Add-get_blkmap-and-put_blkmap.patch
diff options
context:
space:
mode:
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.patch222
1 files changed, 222 insertions, 0 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
new file mode 100644
index 0000000000..1442dfaaed
--- /dev/null
+++ b/meta/recipes-devtools/genext2fs/genext2fs-1.4.1/0003-Add-get_blkmap-and-put_blkmap.patch
@@ -0,0 +1,222 @@
1Upstream-Status: inappropriate
2
3From c196bdeae7932c5d54bbdb7e7574d3cdae46ad02 Mon Sep 17 00:00:00 2001
4From: Corey Minyard <cminyard@mvista.com>
5Date: Sat, 4 Jun 2011 22:04:24 -0500
6Subject: [PATCH 03/19] Add get_blkmap and put_blkmap.
7
8Add routines for getting an putting a block map. This does not do
9anything functional, but is getting ready for when blockmaps are
10byteswapped when being read and written.
11---
12 genext2fs.c | 84 ++++++++++++++++++++++++++++++++++++++++-------------------
13 1 files changed, 57 insertions(+), 27 deletions(-)
14
15diff --git a/genext2fs.c b/genext2fs.c
16index 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--
2211.7.4.1
222
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-04-24 15:18:22 +0000