Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit d3a03f8031000f8297823b80e36db536fd020884

Authored by Joern Engel
1 parent 032d8f7268
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

[LogFS] Plug 8 byte information leak 

Within each journal segment, 8 bytes at offset 24 would remain
uninitialized.

Signed-off-by: Joern Engel <joern@logfs.org>

Showing 1 changed file with 14 additions and 10 deletions Inline Diff

1 /* 1 /*
2 * fs/logfs/journal.c - journal handling code 2 * fs/logfs/journal.c - journal handling code
3 * 3 *
4 * As should be obvious for Linux kernel code, license is GPLv2 4 * As should be obvious for Linux kernel code, license is GPLv2
5 * 5 *
6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org> 6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
7 */ 7 */
8 #include "logfs.h" 8 #include "logfs.h"
9 9
10 static void logfs_calc_free(struct super_block *sb) 10 static void logfs_calc_free(struct super_block *sb)
11 { 11 {
12 struct logfs_super *super = logfs_super(sb); 12 struct logfs_super *super = logfs_super(sb);
13 u64 reserve, no_segs = super->s_no_segs; 13 u64 reserve, no_segs = super->s_no_segs;
14 s64 free; 14 s64 free;
15 int i; 15 int i;
16 16
17 /* superblock segments */ 17 /* superblock segments */
18 no_segs -= 2; 18 no_segs -= 2;
19 super->s_no_journal_segs = 0; 19 super->s_no_journal_segs = 0;
20 /* journal */ 20 /* journal */
21 journal_for_each(i) 21 journal_for_each(i)
22 if (super->s_journal_seg[i]) { 22 if (super->s_journal_seg[i]) {
23 no_segs--; 23 no_segs--;
24 super->s_no_journal_segs++; 24 super->s_no_journal_segs++;
25 } 25 }
26 26
27 /* open segments plus one extra per level for GC */ 27 /* open segments plus one extra per level for GC */
28 no_segs -= 2 * super->s_total_levels; 28 no_segs -= 2 * super->s_total_levels;
29 29
30 free = no_segs * (super->s_segsize - LOGFS_SEGMENT_RESERVE); 30 free = no_segs * (super->s_segsize - LOGFS_SEGMENT_RESERVE);
31 free -= super->s_used_bytes; 31 free -= super->s_used_bytes;
32 /* just a bit extra */ 32 /* just a bit extra */
33 free -= super->s_total_levels * 4096; 33 free -= super->s_total_levels * 4096;
34 34
35 /* Bad blocks are 'paid' for with speed reserve - the filesystem 35 /* Bad blocks are 'paid' for with speed reserve - the filesystem
36 * simply gets slower as bad blocks accumulate. Until the bad blocks 36 * simply gets slower as bad blocks accumulate. Until the bad blocks
37 * exceed the speed reserve - then the filesystem gets smaller. 37 * exceed the speed reserve - then the filesystem gets smaller.
38 */ 38 */
39 reserve = super->s_bad_segments + super->s_bad_seg_reserve; 39 reserve = super->s_bad_segments + super->s_bad_seg_reserve;
40 reserve *= super->s_segsize - LOGFS_SEGMENT_RESERVE; 40 reserve *= super->s_segsize - LOGFS_SEGMENT_RESERVE;
41 reserve = max(reserve, super->s_speed_reserve); 41 reserve = max(reserve, super->s_speed_reserve);
42 free -= reserve; 42 free -= reserve;
43 if (free < 0) 43 if (free < 0)
44 free = 0; 44 free = 0;
45 45
46 super->s_free_bytes = free; 46 super->s_free_bytes = free;
47 } 47 }
48 48
49 static void reserve_sb_and_journal(struct super_block *sb) 49 static void reserve_sb_and_journal(struct super_block *sb)
50 { 50 {
51 struct logfs_super *super = logfs_super(sb); 51 struct logfs_super *super = logfs_super(sb);
52 struct btree_head32 *head = &super->s_reserved_segments; 52 struct btree_head32 *head = &super->s_reserved_segments;
53 int i, err; 53 int i, err;
54 54
55 err = btree_insert32(head, seg_no(sb, super->s_sb_ofs[0]), (void *)1, 55 err = btree_insert32(head, seg_no(sb, super->s_sb_ofs[0]), (void *)1,
56 GFP_KERNEL); 56 GFP_KERNEL);
57 BUG_ON(err); 57 BUG_ON(err);
58 58
59 err = btree_insert32(head, seg_no(sb, super->s_sb_ofs[1]), (void *)1, 59 err = btree_insert32(head, seg_no(sb, super->s_sb_ofs[1]), (void *)1,
60 GFP_KERNEL); 60 GFP_KERNEL);
61 BUG_ON(err); 61 BUG_ON(err);
62 62
63 journal_for_each(i) { 63 journal_for_each(i) {
64 if (!super->s_journal_seg[i]) 64 if (!super->s_journal_seg[i])
65 continue; 65 continue;
66 err = btree_insert32(head, super->s_journal_seg[i], (void *)1, 66 err = btree_insert32(head, super->s_journal_seg[i], (void *)1,
67 GFP_KERNEL); 67 GFP_KERNEL);
68 BUG_ON(err); 68 BUG_ON(err);
69 } 69 }
70 } 70 }
71 71
72 static void read_dynsb(struct super_block *sb, 72 static void read_dynsb(struct super_block *sb,
73 struct logfs_je_dynsb *dynsb) 73 struct logfs_je_dynsb *dynsb)
74 { 74 {
75 struct logfs_super *super = logfs_super(sb); 75 struct logfs_super *super = logfs_super(sb);
76 76
77 super->s_gec = be64_to_cpu(dynsb->ds_gec); 77 super->s_gec = be64_to_cpu(dynsb->ds_gec);
78 super->s_sweeper = be64_to_cpu(dynsb->ds_sweeper); 78 super->s_sweeper = be64_to_cpu(dynsb->ds_sweeper);
79 super->s_victim_ino = be64_to_cpu(dynsb->ds_victim_ino); 79 super->s_victim_ino = be64_to_cpu(dynsb->ds_victim_ino);
80 super->s_rename_dir = be64_to_cpu(dynsb->ds_rename_dir); 80 super->s_rename_dir = be64_to_cpu(dynsb->ds_rename_dir);
81 super->s_rename_pos = be64_to_cpu(dynsb->ds_rename_pos); 81 super->s_rename_pos = be64_to_cpu(dynsb->ds_rename_pos);
82 super->s_used_bytes = be64_to_cpu(dynsb->ds_used_bytes); 82 super->s_used_bytes = be64_to_cpu(dynsb->ds_used_bytes);
83 super->s_generation = be32_to_cpu(dynsb->ds_generation); 83 super->s_generation = be32_to_cpu(dynsb->ds_generation);
84 } 84 }
85 85
86 static void read_anchor(struct super_block *sb, 86 static void read_anchor(struct super_block *sb,
87 struct logfs_je_anchor *da) 87 struct logfs_je_anchor *da)
88 { 88 {
89 struct logfs_super *super = logfs_super(sb); 89 struct logfs_super *super = logfs_super(sb);
90 struct inode *inode = super->s_master_inode; 90 struct inode *inode = super->s_master_inode;
91 struct logfs_inode *li = logfs_inode(inode); 91 struct logfs_inode *li = logfs_inode(inode);
92 int i; 92 int i;
93 93
94 super->s_last_ino = be64_to_cpu(da->da_last_ino); 94 super->s_last_ino = be64_to_cpu(da->da_last_ino);
95 li->li_flags = 0; 95 li->li_flags = 0;
96 li->li_height = da->da_height; 96 li->li_height = da->da_height;
97 i_size_write(inode, be64_to_cpu(da->da_size)); 97 i_size_write(inode, be64_to_cpu(da->da_size));
98 li->li_used_bytes = be64_to_cpu(da->da_used_bytes); 98 li->li_used_bytes = be64_to_cpu(da->da_used_bytes);
99 99
100 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++) 100 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
101 li->li_data[i] = be64_to_cpu(da->da_data[i]); 101 li->li_data[i] = be64_to_cpu(da->da_data[i]);
102 } 102 }
103 103
104 static void read_erasecount(struct super_block *sb, 104 static void read_erasecount(struct super_block *sb,
105 struct logfs_je_journal_ec *ec) 105 struct logfs_je_journal_ec *ec)
106 { 106 {
107 struct logfs_super *super = logfs_super(sb); 107 struct logfs_super *super = logfs_super(sb);
108 int i; 108 int i;
109 109
110 journal_for_each(i) 110 journal_for_each(i)
111 super->s_journal_ec[i] = be32_to_cpu(ec->ec[i]); 111 super->s_journal_ec[i] = be32_to_cpu(ec->ec[i]);
112 } 112 }
113 113
114 static int read_area(struct super_block *sb, struct logfs_je_area *a) 114 static int read_area(struct super_block *sb, struct logfs_je_area *a)
115 { 115 {
116 struct logfs_super *super = logfs_super(sb); 116 struct logfs_super *super = logfs_super(sb);
117 struct logfs_area *area = super->s_area[a->gc_level]; 117 struct logfs_area *area = super->s_area[a->gc_level];
118 u64 ofs; 118 u64 ofs;
119 u32 writemask = ~(super->s_writesize - 1); 119 u32 writemask = ~(super->s_writesize - 1);
120 120
121 if (a->gc_level >= LOGFS_NO_AREAS) 121 if (a->gc_level >= LOGFS_NO_AREAS)
122 return -EIO; 122 return -EIO;
123 if (a->vim != VIM_DEFAULT) 123 if (a->vim != VIM_DEFAULT)
124 return -EIO; /* TODO: close area and continue */ 124 return -EIO; /* TODO: close area and continue */
125 125
126 area->a_used_bytes = be32_to_cpu(a->used_bytes); 126 area->a_used_bytes = be32_to_cpu(a->used_bytes);
127 area->a_written_bytes = area->a_used_bytes & writemask; 127 area->a_written_bytes = area->a_used_bytes & writemask;
128 area->a_segno = be32_to_cpu(a->segno); 128 area->a_segno = be32_to_cpu(a->segno);
129 if (area->a_segno) 129 if (area->a_segno)
130 area->a_is_open = 1; 130 area->a_is_open = 1;
131 131
132 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes); 132 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
133 if (super->s_writesize > 1) 133 if (super->s_writesize > 1)
134 logfs_buf_recover(area, ofs, a + 1, super->s_writesize); 134 logfs_buf_recover(area, ofs, a + 1, super->s_writesize);
135 else 135 else
136 logfs_buf_recover(area, ofs, NULL, 0); 136 logfs_buf_recover(area, ofs, NULL, 0);
137 return 0; 137 return 0;
138 } 138 }
139 139
140 static void *unpack(void *from, void *to) 140 static void *unpack(void *from, void *to)
141 { 141 {
142 struct logfs_journal_header *jh = from; 142 struct logfs_journal_header *jh = from;
143 void *data = from + sizeof(struct logfs_journal_header); 143 void *data = from + sizeof(struct logfs_journal_header);
144 int err; 144 int err;
145 size_t inlen, outlen; 145 size_t inlen, outlen;
146 146
147 inlen = be16_to_cpu(jh->h_len); 147 inlen = be16_to_cpu(jh->h_len);
148 outlen = be16_to_cpu(jh->h_datalen); 148 outlen = be16_to_cpu(jh->h_datalen);
149 149
150 if (jh->h_compr == COMPR_NONE) 150 if (jh->h_compr == COMPR_NONE)
151 memcpy(to, data, inlen); 151 memcpy(to, data, inlen);
152 else { 152 else {
153 err = logfs_uncompress(data, to, inlen, outlen); 153 err = logfs_uncompress(data, to, inlen, outlen);
154 BUG_ON(err); 154 BUG_ON(err);
155 } 155 }
156 return to; 156 return to;
157 } 157 }
158 158
159 static int __read_je_header(struct super_block *sb, u64 ofs, 159 static int __read_je_header(struct super_block *sb, u64 ofs,
160 struct logfs_journal_header *jh) 160 struct logfs_journal_header *jh)
161 { 161 {
162 struct logfs_super *super = logfs_super(sb); 162 struct logfs_super *super = logfs_super(sb);
163 size_t bufsize = max_t(size_t, sb->s_blocksize, super->s_writesize) 163 size_t bufsize = max_t(size_t, sb->s_blocksize, super->s_writesize)
164 + MAX_JOURNAL_HEADER; 164 + MAX_JOURNAL_HEADER;
165 u16 type, len, datalen; 165 u16 type, len, datalen;
166 int err; 166 int err;
167 167
168 /* read header only */ 168 /* read header only */
169 err = wbuf_read(sb, ofs, sizeof(*jh), jh); 169 err = wbuf_read(sb, ofs, sizeof(*jh), jh);
170 if (err) 170 if (err)
171 return err; 171 return err;
172 type = be16_to_cpu(jh->h_type); 172 type = be16_to_cpu(jh->h_type);
173 len = be16_to_cpu(jh->h_len); 173 len = be16_to_cpu(jh->h_len);
174 datalen = be16_to_cpu(jh->h_datalen); 174 datalen = be16_to_cpu(jh->h_datalen);
175 if (len > sb->s_blocksize) 175 if (len > sb->s_blocksize)
176 return -EIO; 176 return -EIO;
177 if ((type < JE_FIRST) || (type > JE_LAST)) 177 if ((type < JE_FIRST) || (type > JE_LAST))
178 return -EIO; 178 return -EIO;
179 if (datalen > bufsize) 179 if (datalen > bufsize)
180 return -EIO; 180 return -EIO;
181 return 0; 181 return 0;
182 } 182 }
183 183
184 static int __read_je_payload(struct super_block *sb, u64 ofs, 184 static int __read_je_payload(struct super_block *sb, u64 ofs,
185 struct logfs_journal_header *jh) 185 struct logfs_journal_header *jh)
186 { 186 {
187 u16 len; 187 u16 len;
188 int err; 188 int err;
189 189
190 len = be16_to_cpu(jh->h_len); 190 len = be16_to_cpu(jh->h_len);
191 err = wbuf_read(sb, ofs + sizeof(*jh), len, jh + 1); 191 err = wbuf_read(sb, ofs + sizeof(*jh), len, jh + 1);
192 if (err) 192 if (err)
193 return err; 193 return err;
194 if (jh->h_crc != logfs_crc32(jh, len + sizeof(*jh), 4)) { 194 if (jh->h_crc != logfs_crc32(jh, len + sizeof(*jh), 4)) {
195 /* Old code was confused. It forgot about the header length 195 /* Old code was confused. It forgot about the header length
196 * and stopped calculating the crc 16 bytes before the end 196 * and stopped calculating the crc 16 bytes before the end
197 * of data - ick! 197 * of data - ick!
198 * FIXME: Remove this hack once the old code is fixed. 198 * FIXME: Remove this hack once the old code is fixed.
199 */ 199 */
200 if (jh->h_crc == logfs_crc32(jh, len, 4)) 200 if (jh->h_crc == logfs_crc32(jh, len, 4))
201 WARN_ON_ONCE(1); 201 WARN_ON_ONCE(1);
202 else 202 else
203 return -EIO; 203 return -EIO;
204 } 204 }
205 return 0; 205 return 0;
206 } 206 }
207 207
208 /* 208 /*
209 * jh needs to be large enough to hold the complete entry, not just the header 209 * jh needs to be large enough to hold the complete entry, not just the header
210 */ 210 */
211 static int __read_je(struct super_block *sb, u64 ofs, 211 static int __read_je(struct super_block *sb, u64 ofs,
212 struct logfs_journal_header *jh) 212 struct logfs_journal_header *jh)
213 { 213 {
214 int err; 214 int err;
215 215
216 err = __read_je_header(sb, ofs, jh); 216 err = __read_je_header(sb, ofs, jh);
217 if (err) 217 if (err)
218 return err; 218 return err;
219 return __read_je_payload(sb, ofs, jh); 219 return __read_je_payload(sb, ofs, jh);
220 } 220 }
221 221
222 static int read_je(struct super_block *sb, u64 ofs) 222 static int read_je(struct super_block *sb, u64 ofs)
223 { 223 {
224 struct logfs_super *super = logfs_super(sb); 224 struct logfs_super *super = logfs_super(sb);
225 struct logfs_journal_header *jh = super->s_compressed_je; 225 struct logfs_journal_header *jh = super->s_compressed_je;
226 void *scratch = super->s_je; 226 void *scratch = super->s_je;
227 u16 type, datalen; 227 u16 type, datalen;
228 int err; 228 int err;
229 229
230 err = __read_je(sb, ofs, jh); 230 err = __read_je(sb, ofs, jh);
231 if (err) 231 if (err)
232 return err; 232 return err;
233 type = be16_to_cpu(jh->h_type); 233 type = be16_to_cpu(jh->h_type);
234 datalen = be16_to_cpu(jh->h_datalen); 234 datalen = be16_to_cpu(jh->h_datalen);
235 235
236 switch (type) { 236 switch (type) {
237 case JE_DYNSB: 237 case JE_DYNSB:
238 read_dynsb(sb, unpack(jh, scratch)); 238 read_dynsb(sb, unpack(jh, scratch));
239 break; 239 break;
240 case JE_ANCHOR: 240 case JE_ANCHOR:
241 read_anchor(sb, unpack(jh, scratch)); 241 read_anchor(sb, unpack(jh, scratch));
242 break; 242 break;
243 case JE_ERASECOUNT: 243 case JE_ERASECOUNT:
244 read_erasecount(sb, unpack(jh, scratch)); 244 read_erasecount(sb, unpack(jh, scratch));
245 break; 245 break;
246 case JE_AREA: 246 case JE_AREA:
247 read_area(sb, unpack(jh, scratch)); 247 read_area(sb, unpack(jh, scratch));
248 break; 248 break;
249 case JE_OBJ_ALIAS: 249 case JE_OBJ_ALIAS:
250 err = logfs_load_object_aliases(sb, unpack(jh, scratch), 250 err = logfs_load_object_aliases(sb, unpack(jh, scratch),
251 datalen); 251 datalen);
252 break; 252 break;
253 default: 253 default:
254 WARN_ON_ONCE(1); 254 WARN_ON_ONCE(1);
255 return -EIO; 255 return -EIO;
256 } 256 }
257 return err; 257 return err;
258 } 258 }
259 259
260 static int logfs_read_segment(struct super_block *sb, u32 segno) 260 static int logfs_read_segment(struct super_block *sb, u32 segno)
261 { 261 {
262 struct logfs_super *super = logfs_super(sb); 262 struct logfs_super *super = logfs_super(sb);
263 struct logfs_journal_header *jh = super->s_compressed_je; 263 struct logfs_journal_header *jh = super->s_compressed_je;
264 u64 ofs, seg_ofs = dev_ofs(sb, segno, 0); 264 u64 ofs, seg_ofs = dev_ofs(sb, segno, 0);
265 u32 h_ofs, last_ofs = 0; 265 u32 h_ofs, last_ofs = 0;
266 u16 len, datalen, last_len = 0; 266 u16 len, datalen, last_len = 0;
267 int i, err; 267 int i, err;
268 268
269 /* search for most recent commit */ 269 /* search for most recent commit */
270 for (h_ofs = 0; h_ofs < super->s_segsize; h_ofs += sizeof(*jh)) { 270 for (h_ofs = 0; h_ofs < super->s_segsize; h_ofs += sizeof(*jh)) {
271 ofs = seg_ofs + h_ofs; 271 ofs = seg_ofs + h_ofs;
272 err = __read_je_header(sb, ofs, jh); 272 err = __read_je_header(sb, ofs, jh);
273 if (err) 273 if (err)
274 continue; 274 continue;
275 if (jh->h_type != cpu_to_be16(JE_COMMIT)) 275 if (jh->h_type != cpu_to_be16(JE_COMMIT))
276 continue; 276 continue;
277 err = __read_je_payload(sb, ofs, jh); 277 err = __read_je_payload(sb, ofs, jh);
278 if (err) 278 if (err)
279 continue; 279 continue;
280 len = be16_to_cpu(jh->h_len); 280 len = be16_to_cpu(jh->h_len);
281 datalen = be16_to_cpu(jh->h_datalen); 281 datalen = be16_to_cpu(jh->h_datalen);
282 if ((datalen > sizeof(super->s_je_array)) || 282 if ((datalen > sizeof(super->s_je_array)) ||
283 (datalen % sizeof(__be64))) 283 (datalen % sizeof(__be64)))
284 continue; 284 continue;
285 last_ofs = h_ofs; 285 last_ofs = h_ofs;
286 last_len = datalen; 286 last_len = datalen;
287 h_ofs += ALIGN(len, sizeof(*jh)) - sizeof(*jh); 287 h_ofs += ALIGN(len, sizeof(*jh)) - sizeof(*jh);
288 } 288 }
289 /* read commit */ 289 /* read commit */
290 if (last_ofs == 0) 290 if (last_ofs == 0)
291 return -ENOENT; 291 return -ENOENT;
292 ofs = seg_ofs + last_ofs; 292 ofs = seg_ofs + last_ofs;
293 log_journal("Read commit from %llx\n", ofs); 293 log_journal("Read commit from %llx\n", ofs);
294 err = __read_je(sb, ofs, jh); 294 err = __read_je(sb, ofs, jh);
295 BUG_ON(err); /* We should have caught it in the scan loop already */ 295 BUG_ON(err); /* We should have caught it in the scan loop already */
296 if (err) 296 if (err)
297 return err; 297 return err;
298 /* uncompress */ 298 /* uncompress */
299 unpack(jh, super->s_je_array); 299 unpack(jh, super->s_je_array);
300 super->s_no_je = last_len / sizeof(__be64); 300 super->s_no_je = last_len / sizeof(__be64);
301 /* iterate over array */ 301 /* iterate over array */
302 for (i = 0; i < super->s_no_je; i++) { 302 for (i = 0; i < super->s_no_je; i++) {
303 err = read_je(sb, be64_to_cpu(super->s_je_array[i])); 303 err = read_je(sb, be64_to_cpu(super->s_je_array[i]));
304 if (err) 304 if (err)
305 return err; 305 return err;
306 } 306 }
307 super->s_journal_area->a_segno = segno; 307 super->s_journal_area->a_segno = segno;
308 return 0; 308 return 0;
309 } 309 }
310 310
311 static u64 read_gec(struct super_block *sb, u32 segno) 311 static u64 read_gec(struct super_block *sb, u32 segno)
312 { 312 {
313 struct logfs_segment_header sh; 313 struct logfs_segment_header sh;
314 __be32 crc; 314 __be32 crc;
315 int err; 315 int err;
316 316
317 if (!segno) 317 if (!segno)
318 return 0; 318 return 0;
319 err = wbuf_read(sb, dev_ofs(sb, segno, 0), sizeof(sh), &sh); 319 err = wbuf_read(sb, dev_ofs(sb, segno, 0), sizeof(sh), &sh);
320 if (err) 320 if (err)
321 return 0; 321 return 0;
322 crc = logfs_crc32(&sh, sizeof(sh), 4); 322 crc = logfs_crc32(&sh, sizeof(sh), 4);
323 if (crc != sh.crc) { 323 if (crc != sh.crc) {
324 WARN_ON(sh.gec != cpu_to_be64(0xffffffffffffffffull)); 324 WARN_ON(sh.gec != cpu_to_be64(0xffffffffffffffffull));
325 /* Most likely it was just erased */ 325 /* Most likely it was just erased */
326 return 0; 326 return 0;
327 } 327 }
328 return be64_to_cpu(sh.gec); 328 return be64_to_cpu(sh.gec);
329 } 329 }
330 330
331 static int logfs_read_journal(struct super_block *sb) 331 static int logfs_read_journal(struct super_block *sb)
332 { 332 {
333 struct logfs_super *super = logfs_super(sb); 333 struct logfs_super *super = logfs_super(sb);
334 u64 gec[LOGFS_JOURNAL_SEGS], max; 334 u64 gec[LOGFS_JOURNAL_SEGS], max;
335 u32 segno; 335 u32 segno;
336 int i, max_i; 336 int i, max_i;
337 337
338 max = 0; 338 max = 0;
339 max_i = -1; 339 max_i = -1;
340 journal_for_each(i) { 340 journal_for_each(i) {
341 segno = super->s_journal_seg[i]; 341 segno = super->s_journal_seg[i];
342 gec[i] = read_gec(sb, super->s_journal_seg[i]); 342 gec[i] = read_gec(sb, super->s_journal_seg[i]);
343 if (gec[i] > max) { 343 if (gec[i] > max) {
344 max = gec[i]; 344 max = gec[i];
345 max_i = i; 345 max_i = i;
346 } 346 }
347 } 347 }
348 if (max_i == -1) 348 if (max_i == -1)
349 return -EIO; 349 return -EIO;
350 /* FIXME: Try older segments in case of error */ 350 /* FIXME: Try older segments in case of error */
351 return logfs_read_segment(sb, super->s_journal_seg[max_i]); 351 return logfs_read_segment(sb, super->s_journal_seg[max_i]);
352 } 352 }
353 353
354 /* 354 /*
355 * First search the current segment (outer loop), then pick the next segment 355 * First search the current segment (outer loop), then pick the next segment
356 * in the array, skipping any zero entries (inner loop). 356 * in the array, skipping any zero entries (inner loop).
357 */ 357 */
358 static void journal_get_free_segment(struct logfs_area *area) 358 static void journal_get_free_segment(struct logfs_area *area)
359 { 359 {
360 struct logfs_super *super = logfs_super(area->a_sb); 360 struct logfs_super *super = logfs_super(area->a_sb);
361 int i; 361 int i;
362 362
363 journal_for_each(i) { 363 journal_for_each(i) {
364 if (area->a_segno != super->s_journal_seg[i]) 364 if (area->a_segno != super->s_journal_seg[i])
365 continue; 365 continue;
366 366
367 do { 367 do {
368 i++; 368 i++;
369 if (i == LOGFS_JOURNAL_SEGS) 369 if (i == LOGFS_JOURNAL_SEGS)
370 i = 0; 370 i = 0;
371 } while (!super->s_journal_seg[i]); 371 } while (!super->s_journal_seg[i]);
372 372
373 area->a_segno = super->s_journal_seg[i]; 373 area->a_segno = super->s_journal_seg[i];
374 area->a_erase_count = ++(super->s_journal_ec[i]); 374 area->a_erase_count = ++(super->s_journal_ec[i]);
375 log_journal("Journal now at %x (ec %x)\n", area->a_segno, 375 log_journal("Journal now at %x (ec %x)\n", area->a_segno,
376 area->a_erase_count); 376 area->a_erase_count);
377 return; 377 return;
378 } 378 }
379 BUG(); 379 BUG();
380 } 380 }
381 381
382 static void journal_get_erase_count(struct logfs_area *area) 382 static void journal_get_erase_count(struct logfs_area *area)
383 { 383 {
384 /* erase count is stored globally and incremented in 384 /* erase count is stored globally and incremented in
385 * journal_get_free_segment() - nothing to do here */ 385 * journal_get_free_segment() - nothing to do here */
386 } 386 }
387 387
388 static int journal_erase_segment(struct logfs_area *area) 388 static int journal_erase_segment(struct logfs_area *area)
389 { 389 {
390 struct super_block *sb = area->a_sb; 390 struct super_block *sb = area->a_sb;
391 struct logfs_segment_header sh; 391 union {
392 struct logfs_segment_header sh;
393 unsigned char c[ALIGN(sizeof(struct logfs_segment_header), 16)];
394 } u;
392 u64 ofs; 395 u64 ofs;
393 int err; 396 int err;
394 397
395 err = logfs_erase_segment(sb, area->a_segno, 1); 398 err = logfs_erase_segment(sb, area->a_segno, 1);
396 if (err) 399 if (err)
397 return err; 400 return err;
398 401
399 sh.pad = 0; 402 memset(&u, 0, sizeof(u));
400 sh.type = SEG_JOURNAL; 403 u.sh.pad = 0;
401 sh.level = 0; 404 u.sh.type = SEG_JOURNAL;
402 sh.segno = cpu_to_be32(area->a_segno); 405 u.sh.level = 0;
403 sh.ec = cpu_to_be32(area->a_erase_count); 406 u.sh.segno = cpu_to_be32(area->a_segno);
404 sh.gec = cpu_to_be64(logfs_super(sb)->s_gec); 407 u.sh.ec = cpu_to_be32(area->a_erase_count);
405 sh.crc = logfs_crc32(&sh, sizeof(sh), 4); 408 u.sh.gec = cpu_to_be64(logfs_super(sb)->s_gec);
409 u.sh.crc = logfs_crc32(&u.sh, sizeof(u.sh), 4);
406 410
407 /* This causes a bug in segment.c. Not yet. */ 411 /* This causes a bug in segment.c. Not yet. */
408 //logfs_set_segment_erased(sb, area->a_segno, area->a_erase_count, 0); 412 //logfs_set_segment_erased(sb, area->a_segno, area->a_erase_count, 0);
409 413
410 ofs = dev_ofs(sb, area->a_segno, 0); 414 ofs = dev_ofs(sb, area->a_segno, 0);
411 area->a_used_bytes = ALIGN(sizeof(sh), 16); 415 area->a_used_bytes = sizeof(u);
412 logfs_buf_write(area, ofs, &sh, sizeof(sh)); 416 logfs_buf_write(area, ofs, &u, sizeof(u));
413 return 0; 417 return 0;
414 } 418 }
415 419
416 static size_t __logfs_write_header(struct logfs_super *super, 420 static size_t __logfs_write_header(struct logfs_super *super,
417 struct logfs_journal_header *jh, size_t len, size_t datalen, 421 struct logfs_journal_header *jh, size_t len, size_t datalen,
418 u16 type, u8 compr) 422 u16 type, u8 compr)
419 { 423 {
420 jh->h_len = cpu_to_be16(len); 424 jh->h_len = cpu_to_be16(len);
421 jh->h_type = cpu_to_be16(type); 425 jh->h_type = cpu_to_be16(type);
422 jh->h_datalen = cpu_to_be16(datalen); 426 jh->h_datalen = cpu_to_be16(datalen);
423 jh->h_compr = compr; 427 jh->h_compr = compr;
424 jh->h_pad[0] = 'H'; 428 jh->h_pad[0] = 'H';
425 jh->h_pad[1] = 'E'; 429 jh->h_pad[1] = 'E';
426 jh->h_pad[2] = 'A'; 430 jh->h_pad[2] = 'A';
427 jh->h_pad[3] = 'D'; 431 jh->h_pad[3] = 'D';
428 jh->h_pad[4] = 'R'; 432 jh->h_pad[4] = 'R';
429 jh->h_crc = logfs_crc32(jh, len + sizeof(*jh), 4); 433 jh->h_crc = logfs_crc32(jh, len + sizeof(*jh), 4);
430 return ALIGN(len, 16) + sizeof(*jh); 434 return ALIGN(len, 16) + sizeof(*jh);
431 } 435 }
432 436
433 static size_t logfs_write_header(struct logfs_super *super, 437 static size_t logfs_write_header(struct logfs_super *super,
434 struct logfs_journal_header *jh, size_t datalen, u16 type) 438 struct logfs_journal_header *jh, size_t datalen, u16 type)
435 { 439 {
436 size_t len = datalen; 440 size_t len = datalen;
437 441
438 return __logfs_write_header(super, jh, len, datalen, type, COMPR_NONE); 442 return __logfs_write_header(super, jh, len, datalen, type, COMPR_NONE);
439 } 443 }
440 444
441 static inline size_t logfs_journal_erasecount_size(struct logfs_super *super) 445 static inline size_t logfs_journal_erasecount_size(struct logfs_super *super)
442 { 446 {
443 return LOGFS_JOURNAL_SEGS * sizeof(__be32); 447 return LOGFS_JOURNAL_SEGS * sizeof(__be32);
444 } 448 }
445 449
446 static void *logfs_write_erasecount(struct super_block *sb, void *_ec, 450 static void *logfs_write_erasecount(struct super_block *sb, void *_ec,
447 u16 *type, size_t *len) 451 u16 *type, size_t *len)
448 { 452 {
449 struct logfs_super *super = logfs_super(sb); 453 struct logfs_super *super = logfs_super(sb);
450 struct logfs_je_journal_ec *ec = _ec; 454 struct logfs_je_journal_ec *ec = _ec;
451 int i; 455 int i;
452 456
453 journal_for_each(i) 457 journal_for_each(i)
454 ec->ec[i] = cpu_to_be32(super->s_journal_ec[i]); 458 ec->ec[i] = cpu_to_be32(super->s_journal_ec[i]);
455 *type = JE_ERASECOUNT; 459 *type = JE_ERASECOUNT;
456 *len = logfs_journal_erasecount_size(super); 460 *len = logfs_journal_erasecount_size(super);
457 return ec; 461 return ec;
458 } 462 }
459 463
460 static void account_shadow(void *_shadow, unsigned long _sb, u64 ignore, 464 static void account_shadow(void *_shadow, unsigned long _sb, u64 ignore,
461 size_t ignore2) 465 size_t ignore2)
462 { 466 {
463 struct logfs_shadow *shadow = _shadow; 467 struct logfs_shadow *shadow = _shadow;
464 struct super_block *sb = (void *)_sb; 468 struct super_block *sb = (void *)_sb;
465 struct logfs_super *super = logfs_super(sb); 469 struct logfs_super *super = logfs_super(sb);
466 470
467 /* consume new space */ 471 /* consume new space */
468 super->s_free_bytes -= shadow->new_len; 472 super->s_free_bytes -= shadow->new_len;
469 super->s_used_bytes += shadow->new_len; 473 super->s_used_bytes += shadow->new_len;
470 super->s_dirty_used_bytes -= shadow->new_len; 474 super->s_dirty_used_bytes -= shadow->new_len;
471 475
472 /* free up old space */ 476 /* free up old space */
473 super->s_free_bytes += shadow->old_len; 477 super->s_free_bytes += shadow->old_len;
474 super->s_used_bytes -= shadow->old_len; 478 super->s_used_bytes -= shadow->old_len;
475 super->s_dirty_free_bytes -= shadow->old_len; 479 super->s_dirty_free_bytes -= shadow->old_len;
476 480
477 logfs_set_segment_used(sb, shadow->old_ofs, -shadow->old_len); 481 logfs_set_segment_used(sb, shadow->old_ofs, -shadow->old_len);
478 logfs_set_segment_used(sb, shadow->new_ofs, shadow->new_len); 482 logfs_set_segment_used(sb, shadow->new_ofs, shadow->new_len);
479 483
480 log_journal("account_shadow(%llx, %llx, %x) %llx->%llx %x->%x\n", 484 log_journal("account_shadow(%llx, %llx, %x) %llx->%llx %x->%x\n",
481 shadow->ino, shadow->bix, shadow->gc_level, 485 shadow->ino, shadow->bix, shadow->gc_level,
482 shadow->old_ofs, shadow->new_ofs, 486 shadow->old_ofs, shadow->new_ofs,
483 shadow->old_len, shadow->new_len); 487 shadow->old_len, shadow->new_len);
484 mempool_free(shadow, super->s_shadow_pool); 488 mempool_free(shadow, super->s_shadow_pool);
485 } 489 }
486 490
487 static void account_shadows(struct super_block *sb) 491 static void account_shadows(struct super_block *sb)
488 { 492 {
489 struct logfs_super *super = logfs_super(sb); 493 struct logfs_super *super = logfs_super(sb);
490 struct inode *inode = super->s_master_inode; 494 struct inode *inode = super->s_master_inode;
491 struct logfs_inode *li = logfs_inode(inode); 495 struct logfs_inode *li = logfs_inode(inode);
492 struct shadow_tree *tree = &super->s_shadow_tree; 496 struct shadow_tree *tree = &super->s_shadow_tree;
493 497
494 btree_grim_visitor64(&tree->new, (unsigned long)sb, account_shadow); 498 btree_grim_visitor64(&tree->new, (unsigned long)sb, account_shadow);
495 btree_grim_visitor64(&tree->old, (unsigned long)sb, account_shadow); 499 btree_grim_visitor64(&tree->old, (unsigned long)sb, account_shadow);
496 btree_grim_visitor32(&tree->segment_map, 0, NULL); 500 btree_grim_visitor32(&tree->segment_map, 0, NULL);
497 tree->no_shadowed_segments = 0; 501 tree->no_shadowed_segments = 0;
498 502
499 if (li->li_block) { 503 if (li->li_block) {
500 /* 504 /*
501 * We never actually use the structure, when attached to the 505 * We never actually use the structure, when attached to the
502 * master inode. But it is easier to always free it here than 506 * master inode. But it is easier to always free it here than
503 * to have checks in several places elsewhere when allocating 507 * to have checks in several places elsewhere when allocating
504 * it. 508 * it.
505 */ 509 */
506 li->li_block->ops->free_block(sb, li->li_block); 510 li->li_block->ops->free_block(sb, li->li_block);
507 } 511 }
508 BUG_ON((s64)li->li_used_bytes < 0); 512 BUG_ON((s64)li->li_used_bytes < 0);
509 } 513 }
510 514
511 static void *__logfs_write_anchor(struct super_block *sb, void *_da, 515 static void *__logfs_write_anchor(struct super_block *sb, void *_da,
512 u16 *type, size_t *len) 516 u16 *type, size_t *len)
513 { 517 {
514 struct logfs_super *super = logfs_super(sb); 518 struct logfs_super *super = logfs_super(sb);
515 struct logfs_je_anchor *da = _da; 519 struct logfs_je_anchor *da = _da;
516 struct inode *inode = super->s_master_inode; 520 struct inode *inode = super->s_master_inode;
517 struct logfs_inode *li = logfs_inode(inode); 521 struct logfs_inode *li = logfs_inode(inode);
518 int i; 522 int i;
519 523
520 da->da_height = li->li_height; 524 da->da_height = li->li_height;
521 da->da_last_ino = cpu_to_be64(super->s_last_ino); 525 da->da_last_ino = cpu_to_be64(super->s_last_ino);
522 da->da_size = cpu_to_be64(i_size_read(inode)); 526 da->da_size = cpu_to_be64(i_size_read(inode));
523 da->da_used_bytes = cpu_to_be64(li->li_used_bytes); 527 da->da_used_bytes = cpu_to_be64(li->li_used_bytes);
524 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++) 528 for (i = 0; i < LOGFS_EMBEDDED_FIELDS; i++)
525 da->da_data[i] = cpu_to_be64(li->li_data[i]); 529 da->da_data[i] = cpu_to_be64(li->li_data[i]);
526 *type = JE_ANCHOR; 530 *type = JE_ANCHOR;
527 *len = sizeof(*da); 531 *len = sizeof(*da);
528 return da; 532 return da;
529 } 533 }
530 534
531 static void *logfs_write_dynsb(struct super_block *sb, void *_dynsb, 535 static void *logfs_write_dynsb(struct super_block *sb, void *_dynsb,
532 u16 *type, size_t *len) 536 u16 *type, size_t *len)
533 { 537 {
534 struct logfs_super *super = logfs_super(sb); 538 struct logfs_super *super = logfs_super(sb);
535 struct logfs_je_dynsb *dynsb = _dynsb; 539 struct logfs_je_dynsb *dynsb = _dynsb;
536 540
537 dynsb->ds_gec = cpu_to_be64(super->s_gec); 541 dynsb->ds_gec = cpu_to_be64(super->s_gec);
538 dynsb->ds_sweeper = cpu_to_be64(super->s_sweeper); 542 dynsb->ds_sweeper = cpu_to_be64(super->s_sweeper);
539 dynsb->ds_victim_ino = cpu_to_be64(super->s_victim_ino); 543 dynsb->ds_victim_ino = cpu_to_be64(super->s_victim_ino);
540 dynsb->ds_rename_dir = cpu_to_be64(super->s_rename_dir); 544 dynsb->ds_rename_dir = cpu_to_be64(super->s_rename_dir);
541 dynsb->ds_rename_pos = cpu_to_be64(super->s_rename_pos); 545 dynsb->ds_rename_pos = cpu_to_be64(super->s_rename_pos);
542 dynsb->ds_used_bytes = cpu_to_be64(super->s_used_bytes); 546 dynsb->ds_used_bytes = cpu_to_be64(super->s_used_bytes);
543 dynsb->ds_generation = cpu_to_be32(super->s_generation); 547 dynsb->ds_generation = cpu_to_be32(super->s_generation);
544 *type = JE_DYNSB; 548 *type = JE_DYNSB;
545 *len = sizeof(*dynsb); 549 *len = sizeof(*dynsb);
546 return dynsb; 550 return dynsb;
547 } 551 }
548 552
549 static void write_wbuf(struct super_block *sb, struct logfs_area *area, 553 static void write_wbuf(struct super_block *sb, struct logfs_area *area,
550 void *wbuf) 554 void *wbuf)
551 { 555 {
552 struct logfs_super *super = logfs_super(sb); 556 struct logfs_super *super = logfs_super(sb);
553 struct address_space *mapping = super->s_mapping_inode->i_mapping; 557 struct address_space *mapping = super->s_mapping_inode->i_mapping;
554 u64 ofs; 558 u64 ofs;
555 pgoff_t index; 559 pgoff_t index;
556 int page_ofs; 560 int page_ofs;
557 struct page *page; 561 struct page *page;
558 562
559 ofs = dev_ofs(sb, area->a_segno, 563 ofs = dev_ofs(sb, area->a_segno,
560 area->a_used_bytes & ~(super->s_writesize - 1)); 564 area->a_used_bytes & ~(super->s_writesize - 1));
561 index = ofs >> PAGE_SHIFT; 565 index = ofs >> PAGE_SHIFT;
562 page_ofs = ofs & (PAGE_SIZE - 1); 566 page_ofs = ofs & (PAGE_SIZE - 1);
563 567
564 page = find_lock_page(mapping, index); 568 page = find_lock_page(mapping, index);
565 BUG_ON(!page); 569 BUG_ON(!page);
566 memcpy(wbuf, page_address(page) + page_ofs, super->s_writesize); 570 memcpy(wbuf, page_address(page) + page_ofs, super->s_writesize);
567 unlock_page(page); 571 unlock_page(page);
568 } 572 }
569 573
570 static void *logfs_write_area(struct super_block *sb, void *_a, 574 static void *logfs_write_area(struct super_block *sb, void *_a,
571 u16 *type, size_t *len) 575 u16 *type, size_t *len)
572 { 576 {
573 struct logfs_super *super = logfs_super(sb); 577 struct logfs_super *super = logfs_super(sb);
574 struct logfs_area *area = super->s_area[super->s_sum_index]; 578 struct logfs_area *area = super->s_area[super->s_sum_index];
575 struct logfs_je_area *a = _a; 579 struct logfs_je_area *a = _a;
576 580
577 a->vim = VIM_DEFAULT; 581 a->vim = VIM_DEFAULT;
578 a->gc_level = super->s_sum_index; 582 a->gc_level = super->s_sum_index;
579 a->used_bytes = cpu_to_be32(area->a_used_bytes); 583 a->used_bytes = cpu_to_be32(area->a_used_bytes);
580 a->segno = cpu_to_be32(area->a_segno); 584 a->segno = cpu_to_be32(area->a_segno);
581 if (super->s_writesize > 1) 585 if (super->s_writesize > 1)
582 write_wbuf(sb, area, a + 1); 586 write_wbuf(sb, area, a + 1);
583 587
584 *type = JE_AREA; 588 *type = JE_AREA;
585 *len = sizeof(*a) + super->s_writesize; 589 *len = sizeof(*a) + super->s_writesize;
586 return a; 590 return a;
587 } 591 }
588 592
589 static void *logfs_write_commit(struct super_block *sb, void *h, 593 static void *logfs_write_commit(struct super_block *sb, void *h,
590 u16 *type, size_t *len) 594 u16 *type, size_t *len)
591 { 595 {
592 struct logfs_super *super = logfs_super(sb); 596 struct logfs_super *super = logfs_super(sb);
593 597
594 *type = JE_COMMIT; 598 *type = JE_COMMIT;
595 *len = super->s_no_je * sizeof(__be64); 599 *len = super->s_no_je * sizeof(__be64);
596 return super->s_je_array; 600 return super->s_je_array;
597 } 601 }
598 602
599 static size_t __logfs_write_je(struct super_block *sb, void *buf, u16 type, 603 static size_t __logfs_write_je(struct super_block *sb, void *buf, u16 type,
600 size_t len) 604 size_t len)
601 { 605 {
602 struct logfs_super *super = logfs_super(sb); 606 struct logfs_super *super = logfs_super(sb);
603 void *header = super->s_compressed_je; 607 void *header = super->s_compressed_je;
604 void *data = header + sizeof(struct logfs_journal_header); 608 void *data = header + sizeof(struct logfs_journal_header);
605 ssize_t compr_len, pad_len; 609 ssize_t compr_len, pad_len;
606 u8 compr = COMPR_ZLIB; 610 u8 compr = COMPR_ZLIB;
607 611
608 if (len == 0) 612 if (len == 0)
609 return logfs_write_header(super, header, 0, type); 613 return logfs_write_header(super, header, 0, type);
610 614
611 compr_len = logfs_compress(buf, data, len, sb->s_blocksize); 615 compr_len = logfs_compress(buf, data, len, sb->s_blocksize);
612 if (compr_len < 0 || type == JE_ANCHOR) { 616 if (compr_len < 0 || type == JE_ANCHOR) {
613 BUG_ON(len > sb->s_blocksize); 617 BUG_ON(len > sb->s_blocksize);
614 memcpy(data, buf, len); 618 memcpy(data, buf, len);
615 compr_len = len; 619 compr_len = len;
616 compr = COMPR_NONE; 620 compr = COMPR_NONE;
617 } 621 }
618 622
619 pad_len = ALIGN(compr_len, 16); 623 pad_len = ALIGN(compr_len, 16);
620 memset(data + compr_len, 0, pad_len - compr_len); 624 memset(data + compr_len, 0, pad_len - compr_len);
621 625
622 return __logfs_write_header(super, header, compr_len, len, type, compr); 626 return __logfs_write_header(super, header, compr_len, len, type, compr);
623 } 627 }
624 628
625 static s64 logfs_get_free_bytes(struct logfs_area *area, size_t *bytes, 629 static s64 logfs_get_free_bytes(struct logfs_area *area, size_t *bytes,
626 int must_pad) 630 int must_pad)
627 { 631 {
628 u32 writesize = logfs_super(area->a_sb)->s_writesize; 632 u32 writesize = logfs_super(area->a_sb)->s_writesize;
629 s32 ofs; 633 s32 ofs;
630 int ret; 634 int ret;
631 635
632 ret = logfs_open_area(area, *bytes); 636 ret = logfs_open_area(area, *bytes);
633 if (ret) 637 if (ret)
634 return -EAGAIN; 638 return -EAGAIN;
635 639
636 ofs = area->a_used_bytes; 640 ofs = area->a_used_bytes;
637 area->a_used_bytes += *bytes; 641 area->a_used_bytes += *bytes;
638 642
639 if (must_pad) { 643 if (must_pad) {
640 area->a_used_bytes = ALIGN(area->a_used_bytes, writesize); 644 area->a_used_bytes = ALIGN(area->a_used_bytes, writesize);
641 *bytes = area->a_used_bytes - ofs; 645 *bytes = area->a_used_bytes - ofs;
642 } 646 }
643 647
644 return dev_ofs(area->a_sb, area->a_segno, ofs); 648 return dev_ofs(area->a_sb, area->a_segno, ofs);
645 } 649 }
646 650
647 static int logfs_write_je_buf(struct super_block *sb, void *buf, u16 type, 651 static int logfs_write_je_buf(struct super_block *sb, void *buf, u16 type,
648 size_t buf_len) 652 size_t buf_len)
649 { 653 {
650 struct logfs_super *super = logfs_super(sb); 654 struct logfs_super *super = logfs_super(sb);
651 struct logfs_area *area = super->s_journal_area; 655 struct logfs_area *area = super->s_journal_area;
652 struct logfs_journal_header *jh = super->s_compressed_je; 656 struct logfs_journal_header *jh = super->s_compressed_je;
653 size_t len; 657 size_t len;
654 int must_pad = 0; 658 int must_pad = 0;
655 s64 ofs; 659 s64 ofs;
656 660
657 len = __logfs_write_je(sb, buf, type, buf_len); 661 len = __logfs_write_je(sb, buf, type, buf_len);
658 if (jh->h_type == cpu_to_be16(JE_COMMIT)) 662 if (jh->h_type == cpu_to_be16(JE_COMMIT))
659 must_pad = 1; 663 must_pad = 1;
660 664
661 ofs = logfs_get_free_bytes(area, &len, must_pad); 665 ofs = logfs_get_free_bytes(area, &len, must_pad);
662 if (ofs < 0) 666 if (ofs < 0)
663 return ofs; 667 return ofs;
664 logfs_buf_write(area, ofs, super->s_compressed_je, len); 668 logfs_buf_write(area, ofs, super->s_compressed_je, len);
665 BUG_ON(super->s_no_je >= MAX_JOURNAL_ENTRIES); 669 BUG_ON(super->s_no_je >= MAX_JOURNAL_ENTRIES);
666 super->s_je_array[super->s_no_je++] = cpu_to_be64(ofs); 670 super->s_je_array[super->s_no_je++] = cpu_to_be64(ofs);
667 return 0; 671 return 0;
668 } 672 }
669 673
670 static int logfs_write_je(struct super_block *sb, 674 static int logfs_write_je(struct super_block *sb,
671 void* (*write)(struct super_block *sb, void *scratch, 675 void* (*write)(struct super_block *sb, void *scratch,
672 u16 *type, size_t *len)) 676 u16 *type, size_t *len))
673 { 677 {
674 void *buf; 678 void *buf;
675 size_t len; 679 size_t len;
676 u16 type; 680 u16 type;
677 681
678 buf = write(sb, logfs_super(sb)->s_je, &type, &len); 682 buf = write(sb, logfs_super(sb)->s_je, &type, &len);
679 return logfs_write_je_buf(sb, buf, type, len); 683 return logfs_write_je_buf(sb, buf, type, len);
680 } 684 }
681 685
682 int write_alias_journal(struct super_block *sb, u64 ino, u64 bix, 686 int write_alias_journal(struct super_block *sb, u64 ino, u64 bix,
683 level_t level, int child_no, __be64 val) 687 level_t level, int child_no, __be64 val)
684 { 688 {
685 struct logfs_super *super = logfs_super(sb); 689 struct logfs_super *super = logfs_super(sb);
686 struct logfs_obj_alias *oa = super->s_je; 690 struct logfs_obj_alias *oa = super->s_je;
687 int err = 0, fill = super->s_je_fill; 691 int err = 0, fill = super->s_je_fill;
688 692
689 log_aliases("logfs_write_obj_aliases #%x(%llx, %llx, %x, %x) %llx\n", 693 log_aliases("logfs_write_obj_aliases #%x(%llx, %llx, %x, %x) %llx\n",
690 fill, ino, bix, level, child_no, be64_to_cpu(val)); 694 fill, ino, bix, level, child_no, be64_to_cpu(val));
691 oa[fill].ino = cpu_to_be64(ino); 695 oa[fill].ino = cpu_to_be64(ino);
692 oa[fill].bix = cpu_to_be64(bix); 696 oa[fill].bix = cpu_to_be64(bix);
693 oa[fill].val = val; 697 oa[fill].val = val;
694 oa[fill].level = (__force u8)level; 698 oa[fill].level = (__force u8)level;
695 oa[fill].child_no = cpu_to_be16(child_no); 699 oa[fill].child_no = cpu_to_be16(child_no);
696 fill++; 700 fill++;
697 if (fill >= sb->s_blocksize / sizeof(*oa)) { 701 if (fill >= sb->s_blocksize / sizeof(*oa)) {
698 err = logfs_write_je_buf(sb, oa, JE_OBJ_ALIAS, sb->s_blocksize); 702 err = logfs_write_je_buf(sb, oa, JE_OBJ_ALIAS, sb->s_blocksize);
699 fill = 0; 703 fill = 0;
700 } 704 }
701 705
702 super->s_je_fill = fill; 706 super->s_je_fill = fill;
703 return err; 707 return err;
704 } 708 }
705 709
706 static int logfs_write_obj_aliases(struct super_block *sb) 710 static int logfs_write_obj_aliases(struct super_block *sb)
707 { 711 {
708 struct logfs_super *super = logfs_super(sb); 712 struct logfs_super *super = logfs_super(sb);
709 int err; 713 int err;
710 714
711 log_journal("logfs_write_obj_aliases: %d aliases to write\n", 715 log_journal("logfs_write_obj_aliases: %d aliases to write\n",
712 super->s_no_object_aliases); 716 super->s_no_object_aliases);
713 super->s_je_fill = 0; 717 super->s_je_fill = 0;
714 err = logfs_write_obj_aliases_pagecache(sb); 718 err = logfs_write_obj_aliases_pagecache(sb);
715 if (err) 719 if (err)
716 return err; 720 return err;
717 721
718 if (super->s_je_fill) 722 if (super->s_je_fill)
719 err = logfs_write_je_buf(sb, super->s_je, JE_OBJ_ALIAS, 723 err = logfs_write_je_buf(sb, super->s_je, JE_OBJ_ALIAS,
720 super->s_je_fill 724 super->s_je_fill
721 * sizeof(struct logfs_obj_alias)); 725 * sizeof(struct logfs_obj_alias));
722 return err; 726 return err;
723 } 727 }
724 728
725 /* 729 /*
726 * Write all journal entries. The goto logic ensures that all journal entries 730 * Write all journal entries. The goto logic ensures that all journal entries
727 * are written whenever a new segment is used. It is ugly and potentially a 731 * are written whenever a new segment is used. It is ugly and potentially a
728 * bit wasteful, but robustness is more important. With this we can *always* 732 * bit wasteful, but robustness is more important. With this we can *always*
729 * erase all journal segments except the one containing the most recent commit. 733 * erase all journal segments except the one containing the most recent commit.
730 */ 734 */
731 void logfs_write_anchor(struct super_block *sb) 735 void logfs_write_anchor(struct super_block *sb)
732 { 736 {
733 struct logfs_super *super = logfs_super(sb); 737 struct logfs_super *super = logfs_super(sb);
734 struct logfs_area *area = super->s_journal_area; 738 struct logfs_area *area = super->s_journal_area;
735 int i, err; 739 int i, err;
736 740
737 if (!(super->s_flags & LOGFS_SB_FLAG_DIRTY)) 741 if (!(super->s_flags & LOGFS_SB_FLAG_DIRTY))
738 return; 742 return;
739 super->s_flags &= ~LOGFS_SB_FLAG_DIRTY; 743 super->s_flags &= ~LOGFS_SB_FLAG_DIRTY;
740 744
741 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN); 745 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
742 mutex_lock(&super->s_journal_mutex); 746 mutex_lock(&super->s_journal_mutex);
743 747
744 /* Do this first or suffer corruption */ 748 /* Do this first or suffer corruption */
745 logfs_sync_segments(sb); 749 logfs_sync_segments(sb);
746 account_shadows(sb); 750 account_shadows(sb);
747 751
748 again: 752 again:
749 super->s_no_je = 0; 753 super->s_no_je = 0;
750 for_each_area(i) { 754 for_each_area(i) {
751 if (!super->s_area[i]->a_is_open) 755 if (!super->s_area[i]->a_is_open)
752 continue; 756 continue;
753 super->s_sum_index = i; 757 super->s_sum_index = i;
754 err = logfs_write_je(sb, logfs_write_area); 758 err = logfs_write_je(sb, logfs_write_area);
755 if (err) 759 if (err)
756 goto again; 760 goto again;
757 } 761 }
758 err = logfs_write_obj_aliases(sb); 762 err = logfs_write_obj_aliases(sb);
759 if (err) 763 if (err)
760 goto again; 764 goto again;
761 err = logfs_write_je(sb, logfs_write_erasecount); 765 err = logfs_write_je(sb, logfs_write_erasecount);
762 if (err) 766 if (err)
763 goto again; 767 goto again;
764 err = logfs_write_je(sb, __logfs_write_anchor); 768 err = logfs_write_je(sb, __logfs_write_anchor);
765 if (err) 769 if (err)
766 goto again; 770 goto again;
767 err = logfs_write_je(sb, logfs_write_dynsb); 771 err = logfs_write_je(sb, logfs_write_dynsb);
768 if (err) 772 if (err)
769 goto again; 773 goto again;
770 /* 774 /*
771 * Order is imperative. First we sync all writes, including the 775 * Order is imperative. First we sync all writes, including the
772 * non-committed journal writes. Then we write the final commit and 776 * non-committed journal writes. Then we write the final commit and
773 * sync the current journal segment. 777 * sync the current journal segment.
774 * There is a theoretical bug here. Syncing the journal segment will 778 * There is a theoretical bug here. Syncing the journal segment will
775 * write a number of journal entries and the final commit. All these 779 * write a number of journal entries and the final commit. All these
776 * are written in a single operation. If the device layer writes the 780 * are written in a single operation. If the device layer writes the
777 * data back-to-front, the commit will precede the other journal 781 * data back-to-front, the commit will precede the other journal
778 * entries, leaving a race window. 782 * entries, leaving a race window.
779 * Two fixes are possible. Preferred is to fix the device layer to 783 * Two fixes are possible. Preferred is to fix the device layer to
780 * ensure writes happen front-to-back. Alternatively we can insert 784 * ensure writes happen front-to-back. Alternatively we can insert
781 * another logfs_sync_area() super->s_devops->sync() combo before 785 * another logfs_sync_area() super->s_devops->sync() combo before
782 * writing the commit. 786 * writing the commit.
783 */ 787 */
784 /* 788 /*
785 * On another subject, super->s_devops->sync is usually not necessary. 789 * On another subject, super->s_devops->sync is usually not necessary.
786 * Unless called from sys_sync or friends, a barrier would suffice. 790 * Unless called from sys_sync or friends, a barrier would suffice.
787 */ 791 */
788 super->s_devops->sync(sb); 792 super->s_devops->sync(sb);
789 err = logfs_write_je(sb, logfs_write_commit); 793 err = logfs_write_je(sb, logfs_write_commit);
790 if (err) 794 if (err)
791 goto again; 795 goto again;
792 log_journal("Write commit to %llx\n", 796 log_journal("Write commit to %llx\n",
793 be64_to_cpu(super->s_je_array[super->s_no_je - 1])); 797 be64_to_cpu(super->s_je_array[super->s_no_je - 1]));
794 logfs_sync_area(area); 798 logfs_sync_area(area);
795 BUG_ON(area->a_used_bytes != area->a_written_bytes); 799 BUG_ON(area->a_used_bytes != area->a_written_bytes);
796 super->s_devops->sync(sb); 800 super->s_devops->sync(sb);
797 801
798 mutex_unlock(&super->s_journal_mutex); 802 mutex_unlock(&super->s_journal_mutex);
799 return; 803 return;
800 } 804 }
801 805
802 void do_logfs_journal_wl_pass(struct super_block *sb) 806 void do_logfs_journal_wl_pass(struct super_block *sb)
803 { 807 {
804 struct logfs_super *super = logfs_super(sb); 808 struct logfs_super *super = logfs_super(sb);
805 struct logfs_area *area = super->s_journal_area; 809 struct logfs_area *area = super->s_journal_area;
806 struct btree_head32 *head = &super->s_reserved_segments; 810 struct btree_head32 *head = &super->s_reserved_segments;
807 u32 segno, ec; 811 u32 segno, ec;
808 int i, err; 812 int i, err;
809 813
810 log_journal("Journal requires wear-leveling.\n"); 814 log_journal("Journal requires wear-leveling.\n");
811 /* Drop old segments */ 815 /* Drop old segments */
812 journal_for_each(i) 816 journal_for_each(i)
813 if (super->s_journal_seg[i]) { 817 if (super->s_journal_seg[i]) {
814 btree_remove32(head, super->s_journal_seg[i]); 818 btree_remove32(head, super->s_journal_seg[i]);
815 logfs_set_segment_unreserved(sb, 819 logfs_set_segment_unreserved(sb,
816 super->s_journal_seg[i], 820 super->s_journal_seg[i],
817 super->s_journal_ec[i]); 821 super->s_journal_ec[i]);
818 super->s_journal_seg[i] = 0; 822 super->s_journal_seg[i] = 0;
819 super->s_journal_ec[i] = 0; 823 super->s_journal_ec[i] = 0;
820 } 824 }
821 /* Get new segments */ 825 /* Get new segments */
822 for (i = 0; i < super->s_no_journal_segs; i++) { 826 for (i = 0; i < super->s_no_journal_segs; i++) {
823 segno = get_best_cand(sb, &super->s_reserve_list, &ec); 827 segno = get_best_cand(sb, &super->s_reserve_list, &ec);
824 super->s_journal_seg[i] = segno; 828 super->s_journal_seg[i] = segno;
825 super->s_journal_ec[i] = ec; 829 super->s_journal_ec[i] = ec;
826 logfs_set_segment_reserved(sb, segno); 830 logfs_set_segment_reserved(sb, segno);
827 err = btree_insert32(head, segno, (void *)1, GFP_KERNEL); 831 err = btree_insert32(head, segno, (void *)1, GFP_KERNEL);
828 BUG_ON(err); /* mempool should prevent this */ 832 BUG_ON(err); /* mempool should prevent this */
829 err = logfs_erase_segment(sb, segno, 1); 833 err = logfs_erase_segment(sb, segno, 1);
830 BUG_ON(err); /* FIXME: remount-ro would be nicer */ 834 BUG_ON(err); /* FIXME: remount-ro would be nicer */
831 } 835 }
832 /* Manually move journal_area */ 836 /* Manually move journal_area */
833 freeseg(sb, area->a_segno); 837 freeseg(sb, area->a_segno);
834 area->a_segno = super->s_journal_seg[0]; 838 area->a_segno = super->s_journal_seg[0];
835 area->a_is_open = 0; 839 area->a_is_open = 0;
836 area->a_used_bytes = 0; 840 area->a_used_bytes = 0;
837 /* Write journal */ 841 /* Write journal */
838 logfs_write_anchor(sb); 842 logfs_write_anchor(sb);
839 /* Write superblocks */ 843 /* Write superblocks */
840 err = logfs_write_sb(sb); 844 err = logfs_write_sb(sb);
841 BUG_ON(err); 845 BUG_ON(err);
842 } 846 }
843 847
844 static const struct logfs_area_ops journal_area_ops = { 848 static const struct logfs_area_ops journal_area_ops = {
845 .get_free_segment = journal_get_free_segment, 849 .get_free_segment = journal_get_free_segment,
846 .get_erase_count = journal_get_erase_count, 850 .get_erase_count = journal_get_erase_count,
847 .erase_segment = journal_erase_segment, 851 .erase_segment = journal_erase_segment,
848 }; 852 };
849 853
850 int logfs_init_journal(struct super_block *sb) 854 int logfs_init_journal(struct super_block *sb)
851 { 855 {
852 struct logfs_super *super = logfs_super(sb); 856 struct logfs_super *super = logfs_super(sb);
853 size_t bufsize = max_t(size_t, sb->s_blocksize, super->s_writesize) 857 size_t bufsize = max_t(size_t, sb->s_blocksize, super->s_writesize)
854 + MAX_JOURNAL_HEADER; 858 + MAX_JOURNAL_HEADER;
855 int ret = -ENOMEM; 859 int ret = -ENOMEM;
856 860
857 mutex_init(&super->s_journal_mutex); 861 mutex_init(&super->s_journal_mutex);
858 btree_init_mempool32(&super->s_reserved_segments, super->s_btree_pool); 862 btree_init_mempool32(&super->s_reserved_segments, super->s_btree_pool);
859 863
860 super->s_je = kzalloc(bufsize, GFP_KERNEL); 864 super->s_je = kzalloc(bufsize, GFP_KERNEL);
861 if (!super->s_je) 865 if (!super->s_je)
862 return ret; 866 return ret;
863 867
864 super->s_compressed_je = kzalloc(bufsize, GFP_KERNEL); 868 super->s_compressed_je = kzalloc(bufsize, GFP_KERNEL);
865 if (!super->s_compressed_je) 869 if (!super->s_compressed_je)
866 return ret; 870 return ret;
867 871
868 super->s_master_inode = logfs_new_meta_inode(sb, LOGFS_INO_MASTER); 872 super->s_master_inode = logfs_new_meta_inode(sb, LOGFS_INO_MASTER);
869 if (IS_ERR(super->s_master_inode)) 873 if (IS_ERR(super->s_master_inode))
870 return PTR_ERR(super->s_master_inode); 874 return PTR_ERR(super->s_master_inode);
871 875
872 ret = logfs_read_journal(sb); 876 ret = logfs_read_journal(sb);
873 if (ret) 877 if (ret)
874 return -EIO; 878 return -EIO;
875 879
876 reserve_sb_and_journal(sb); 880 reserve_sb_and_journal(sb);
877 logfs_calc_free(sb); 881 logfs_calc_free(sb);
878 882
879 super->s_journal_area->a_ops = &journal_area_ops; 883 super->s_journal_area->a_ops = &journal_area_ops;
880 return 0; 884 return 0;
881 } 885 }
882 886
883 void logfs_cleanup_journal(struct super_block *sb) 887 void logfs_cleanup_journal(struct super_block *sb)
884 { 888 {
885 struct logfs_super *super = logfs_super(sb); 889 struct logfs_super *super = logfs_super(sb);
886 890
887 btree_grim_visitor32(&super->s_reserved_segments, 0, NULL); 891 btree_grim_visitor32(&super->s_reserved_segments, 0, NULL);
888 destroy_meta_inode(super->s_master_inode); 892 destroy_meta_inode(super->s_master_inode);
889 super->s_master_inode = NULL; 893 super->s_master_inode = NULL;
890 894
891 kfree(super->s_compressed_je); 895 kfree(super->s_compressed_je);
892 kfree(super->s_je); 896 kfree(super->s_je);
893 } 897 }
894 898