aboutsummaryrefslogtreecommitdiffstats
path: root/fs/logfs/segment.c
diff options
context:
space:
mode:
Diffstat (limited to 'fs/logfs/segment.c')
-rw-r--r--fs/logfs/segment.c927
1 files changed, 927 insertions, 0 deletions
diff --git a/fs/logfs/segment.c b/fs/logfs/segment.c
new file mode 100644
index 000000000000..1a14f9910d55
--- /dev/null
+++ b/fs/logfs/segment.c
@@ -0,0 +1,927 @@
1/*
2 * fs/logfs/segment.c - Handling the Object Store
3 *
4 * As should be obvious for Linux kernel code, license is GPLv2
5 *
6 * Copyright (c) 2005-2008 Joern Engel <joern@logfs.org>
7 *
8 * Object store or ostore makes up the complete device with exception of
9 * the superblock and journal areas. Apart from its own metadata it stores
10 * three kinds of objects: inodes, dentries and blocks, both data and indirect.
11 */
12#include "logfs.h"
13
14static int logfs_mark_segment_bad(struct super_block *sb, u32 segno)
15{
16 struct logfs_super *super = logfs_super(sb);
17 struct btree_head32 *head = &super->s_reserved_segments;
18 int err;
19
20 err = btree_insert32(head, segno, (void *)1, GFP_NOFS);
21 if (err)
22 return err;
23 logfs_super(sb)->s_bad_segments++;
24 /* FIXME: write to journal */
25 return 0;
26}
27
28int logfs_erase_segment(struct super_block *sb, u32 segno, int ensure_erase)
29{
30 struct logfs_super *super = logfs_super(sb);
31
32 super->s_gec++;
33
34 return super->s_devops->erase(sb, (u64)segno << super->s_segshift,
35 super->s_segsize, ensure_erase);
36}
37
38static s64 logfs_get_free_bytes(struct logfs_area *area, size_t bytes)
39{
40 s32 ofs;
41
42 logfs_open_area(area, bytes);
43
44 ofs = area->a_used_bytes;
45 area->a_used_bytes += bytes;
46 BUG_ON(area->a_used_bytes >= logfs_super(area->a_sb)->s_segsize);
47
48 return dev_ofs(area->a_sb, area->a_segno, ofs);
49}
50
51static struct page *get_mapping_page(struct super_block *sb, pgoff_t index,
52 int use_filler)
53{
54 struct logfs_super *super = logfs_super(sb);
55 struct address_space *mapping = super->s_mapping_inode->i_mapping;
56 filler_t *filler = super->s_devops->readpage;
57 struct page *page;
58
59 BUG_ON(mapping_gfp_mask(mapping) & __GFP_FS);
60 if (use_filler)
61 page = read_cache_page(mapping, index, filler, sb);
62 else {
63 page = find_or_create_page(mapping, index, GFP_NOFS);
64 unlock_page(page);
65 }
66 return page;
67}
68
69void __logfs_buf_write(struct logfs_area *area, u64 ofs, void *buf, size_t len,
70 int use_filler)
71{
72 pgoff_t index = ofs >> PAGE_SHIFT;
73 struct page *page;
74 long offset = ofs & (PAGE_SIZE-1);
75 long copylen;
76
77 /* Only logfs_wbuf_recover may use len==0 */
78 BUG_ON(!len && !use_filler);
79 do {
80 copylen = min((ulong)len, PAGE_SIZE - offset);
81
82 page = get_mapping_page(area->a_sb, index, use_filler);
83 SetPageUptodate(page);
84 BUG_ON(!page); /* FIXME: reserve a pool */
85 memcpy(page_address(page) + offset, buf, copylen);
86 SetPagePrivate(page);
87 page_cache_release(page);
88
89 buf += copylen;
90 len -= copylen;
91 offset = 0;
92 index++;
93 } while (len);
94}
95
96/*
97 * bdev_writeseg will write full pages. Memset the tail to prevent data leaks.
98 */
99static void pad_wbuf(struct logfs_area *area, int final)
100{
101 struct super_block *sb = area->a_sb;
102 struct logfs_super *super = logfs_super(sb);
103 struct page *page;
104 u64 ofs = dev_ofs(sb, area->a_segno, area->a_used_bytes);
105 pgoff_t index = ofs >> PAGE_SHIFT;
106 long offset = ofs & (PAGE_SIZE-1);
107 u32 len = PAGE_SIZE - offset;
108
109 if (len == PAGE_SIZE) {
110 /* The math in this function can surely use some love */
111 len = 0;
112 }
113 if (len) {
114 BUG_ON(area->a_used_bytes >= super->s_segsize);
115
116 page = get_mapping_page(area->a_sb, index, 0);
117 BUG_ON(!page); /* FIXME: reserve a pool */
118 memset(page_address(page) + offset, 0xff, len);
119 SetPagePrivate(page);
120 page_cache_release(page);
121 }
122
123 if (!final)
124 return;
125
126 area->a_used_bytes += len;
127 for ( ; area->a_used_bytes < super->s_segsize;
128 area->a_used_bytes += PAGE_SIZE) {
129 /* Memset another page */
130 index++;
131 page = get_mapping_page(area->a_sb, index, 0);
132 BUG_ON(!page); /* FIXME: reserve a pool */
133 memset(page_address(page), 0xff, PAGE_SIZE);
134 SetPagePrivate(page);
135 page_cache_release(page);
136 }
137}
138
139/*
140 * We have to be careful with the alias tree. Since lookup is done by bix,
141 * it needs to be normalized, so 14, 15, 16, etc. all match when dealing with
142 * indirect blocks. So always use it through accessor functions.
143 */
144static void *alias_tree_lookup(struct super_block *sb, u64 ino, u64 bix,
145 level_t level)
146{
147 struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree;
148 pgoff_t index = logfs_pack_index(bix, level);
149
150 return btree_lookup128(head, ino, index);
151}
152
153static int alias_tree_insert(struct super_block *sb, u64 ino, u64 bix,
154 level_t level, void *val)
155{
156 struct btree_head128 *head = &logfs_super(sb)->s_object_alias_tree;
157 pgoff_t index = logfs_pack_index(bix, level);
158
159 return btree_insert128(head, ino, index, val, GFP_NOFS);
160}
161
162static int btree_write_alias(struct super_block *sb, struct logfs_block *block,
163 write_alias_t *write_one_alias)
164{
165 struct object_alias_item *item;
166 int err;
167
168 list_for_each_entry(item, &block->item_list, list) {
169 err = write_alias_journal(sb, block->ino, block->bix,
170 block->level, item->child_no, item->val);
171 if (err)
172 return err;
173 }
174 return 0;
175}
176
177static gc_level_t btree_block_level(struct logfs_block *block)
178{
179 return expand_level(block->ino, block->level);
180}
181
182static struct logfs_block_ops btree_block_ops = {
183 .write_block = btree_write_block,
184 .block_level = btree_block_level,
185 .free_block = __free_block,
186 .write_alias = btree_write_alias,
187};
188
189int logfs_load_object_aliases(struct super_block *sb,
190 struct logfs_obj_alias *oa, int count)
191{
192 struct logfs_super *super = logfs_super(sb);
193 struct logfs_block *block;
194 struct object_alias_item *item;
195 u64 ino, bix;
196 level_t level;
197 int i, err;
198
199 super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS;
200 count /= sizeof(*oa);
201 for (i = 0; i < count; i++) {
202 item = mempool_alloc(super->s_alias_pool, GFP_NOFS);
203 if (!item)
204 return -ENOMEM;
205 memset(item, 0, sizeof(*item));
206
207 super->s_no_object_aliases++;
208 item->val = oa[i].val;
209 item->child_no = be16_to_cpu(oa[i].child_no);
210
211 ino = be64_to_cpu(oa[i].ino);
212 bix = be64_to_cpu(oa[i].bix);
213 level = LEVEL(oa[i].level);
214
215 log_aliases("logfs_load_object_aliases(%llx, %llx, %x, %x) %llx\n",
216 ino, bix, level, item->child_no,
217 be64_to_cpu(item->val));
218 block = alias_tree_lookup(sb, ino, bix, level);
219 if (!block) {
220 block = __alloc_block(sb, ino, bix, level);
221 block->ops = &btree_block_ops;
222 err = alias_tree_insert(sb, ino, bix, level, block);
223 BUG_ON(err); /* mempool empty */
224 }
225 if (test_and_set_bit(item->child_no, block->alias_map)) {
226 printk(KERN_ERR"LogFS: Alias collision detected\n");
227 return -EIO;
228 }
229 list_move_tail(&block->alias_list, &super->s_object_alias);
230 list_add(&item->list, &block->item_list);
231 }
232 return 0;
233}
234
235static void kill_alias(void *_block, unsigned long ignore0,
236 u64 ignore1, u64 ignore2, size_t ignore3)
237{
238 struct logfs_block *block = _block;
239 struct super_block *sb = block->sb;
240 struct logfs_super *super = logfs_super(sb);
241 struct object_alias_item *item;
242
243 while (!list_empty(&block->item_list)) {
244 item = list_entry(block->item_list.next, typeof(*item), list);
245 list_del(&item->list);
246 mempool_free(item, super->s_alias_pool);
247 }
248 block->ops->free_block(sb, block);
249}
250
251static int obj_type(struct inode *inode, level_t level)
252{
253 if (level == 0) {
254 if (S_ISDIR(inode->i_mode))
255 return OBJ_DENTRY;
256 if (inode->i_ino == LOGFS_INO_MASTER)
257 return OBJ_INODE;
258 }
259 return OBJ_BLOCK;
260}
261
262static int obj_len(struct super_block *sb, int obj_type)
263{
264 switch (obj_type) {
265 case OBJ_DENTRY:
266 return sizeof(struct logfs_disk_dentry);
267 case OBJ_INODE:
268 return sizeof(struct logfs_disk_inode);
269 case OBJ_BLOCK:
270 return sb->s_blocksize;
271 default:
272 BUG();
273 }
274}
275
276static int __logfs_segment_write(struct inode *inode, void *buf,
277 struct logfs_shadow *shadow, int type, int len, int compr)
278{
279 struct logfs_area *area;
280 struct super_block *sb = inode->i_sb;
281 s64 ofs;
282 struct logfs_object_header h;
283 int acc_len;
284
285 if (shadow->gc_level == 0)
286 acc_len = len;
287 else
288 acc_len = obj_len(sb, type);
289
290 area = get_area(sb, shadow->gc_level);
291 ofs = logfs_get_free_bytes(area, len + LOGFS_OBJECT_HEADERSIZE);
292 LOGFS_BUG_ON(ofs <= 0, sb);
293 /*
294 * Order is important. logfs_get_free_bytes(), by modifying the
295 * segment file, may modify the content of the very page we're about
296 * to write now. Which is fine, as long as the calculated crc and
297 * written data still match. So do the modifications _before_
298 * calculating the crc.
299 */
300
301 h.len = cpu_to_be16(len);
302 h.type = type;
303 h.compr = compr;
304 h.ino = cpu_to_be64(inode->i_ino);
305 h.bix = cpu_to_be64(shadow->bix);
306 h.crc = logfs_crc32(&h, sizeof(h) - 4, 4);
307 h.data_crc = logfs_crc32(buf, len, 0);
308
309 logfs_buf_write(area, ofs, &h, sizeof(h));
310 logfs_buf_write(area, ofs + LOGFS_OBJECT_HEADERSIZE, buf, len);
311
312 shadow->new_ofs = ofs;
313 shadow->new_len = acc_len + LOGFS_OBJECT_HEADERSIZE;
314
315 return 0;
316}
317
318static s64 logfs_segment_write_compress(struct inode *inode, void *buf,
319 struct logfs_shadow *shadow, int type, int len)
320{
321 struct super_block *sb = inode->i_sb;
322 void *compressor_buf = logfs_super(sb)->s_compressed_je;
323 ssize_t compr_len;
324 int ret;
325
326 mutex_lock(&logfs_super(sb)->s_journal_mutex);
327 compr_len = logfs_compress(buf, compressor_buf, len, len);
328
329 if (compr_len >= 0) {
330 ret = __logfs_segment_write(inode, compressor_buf, shadow,
331 type, compr_len, COMPR_ZLIB);
332 } else {
333 ret = __logfs_segment_write(inode, buf, shadow, type, len,
334 COMPR_NONE);
335 }
336 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
337 return ret;
338}
339
340/**
341 * logfs_segment_write - write data block to object store
342 * @inode: inode containing data
343 *
344 * Returns an errno or zero.
345 */
346int logfs_segment_write(struct inode *inode, struct page *page,
347 struct logfs_shadow *shadow)
348{
349 struct super_block *sb = inode->i_sb;
350 struct logfs_super *super = logfs_super(sb);
351 int do_compress, type, len;
352 int ret;
353 void *buf;
354
355 super->s_flags |= LOGFS_SB_FLAG_DIRTY;
356 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
357 do_compress = logfs_inode(inode)->li_flags & LOGFS_IF_COMPRESSED;
358 if (shadow->gc_level != 0) {
359 /* temporarily disable compression for indirect blocks */
360 do_compress = 0;
361 }
362
363 type = obj_type(inode, shrink_level(shadow->gc_level));
364 len = obj_len(sb, type);
365 buf = kmap(page);
366 if (do_compress)
367 ret = logfs_segment_write_compress(inode, buf, shadow, type,
368 len);
369 else
370 ret = __logfs_segment_write(inode, buf, shadow, type, len,
371 COMPR_NONE);
372 kunmap(page);
373
374 log_segment("logfs_segment_write(%llx, %llx, %x) %llx->%llx %x->%x\n",
375 shadow->ino, shadow->bix, shadow->gc_level,
376 shadow->old_ofs, shadow->new_ofs,
377 shadow->old_len, shadow->new_len);
378 /* this BUG_ON did catch a locking bug. useful */
379 BUG_ON(!(shadow->new_ofs & (super->s_segsize - 1)));
380 return ret;
381}
382
383int wbuf_read(struct super_block *sb, u64 ofs, size_t len, void *buf)
384{
385 pgoff_t index = ofs >> PAGE_SHIFT;
386 struct page *page;
387 long offset = ofs & (PAGE_SIZE-1);
388 long copylen;
389
390 while (len) {
391 copylen = min((ulong)len, PAGE_SIZE - offset);
392
393 page = get_mapping_page(sb, index, 1);
394 if (IS_ERR(page))
395 return PTR_ERR(page);
396 memcpy(buf, page_address(page) + offset, copylen);
397 page_cache_release(page);
398
399 buf += copylen;
400 len -= copylen;
401 offset = 0;
402 index++;
403 }
404 return 0;
405}
406
407/*
408 * The "position" of indirect blocks is ambiguous. It can be the position
409 * of any data block somewhere behind this indirect block. So we need to
410 * normalize the positions through logfs_block_mask() before comparing.
411 */
412static int check_pos(struct super_block *sb, u64 pos1, u64 pos2, level_t level)
413{
414 return (pos1 & logfs_block_mask(sb, level)) !=
415 (pos2 & logfs_block_mask(sb, level));
416}
417
418#if 0
419static int read_seg_header(struct super_block *sb, u64 ofs,
420 struct logfs_segment_header *sh)
421{
422 __be32 crc;
423 int err;
424
425 err = wbuf_read(sb, ofs, sizeof(*sh), sh);
426 if (err)
427 return err;
428 crc = logfs_crc32(sh, sizeof(*sh), 4);
429 if (crc != sh->crc) {
430 printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, "
431 "got %x\n", ofs, be32_to_cpu(sh->crc),
432 be32_to_cpu(crc));
433 return -EIO;
434 }
435 return 0;
436}
437#endif
438
439static int read_obj_header(struct super_block *sb, u64 ofs,
440 struct logfs_object_header *oh)
441{
442 __be32 crc;
443 int err;
444
445 err = wbuf_read(sb, ofs, sizeof(*oh), oh);
446 if (err)
447 return err;
448 crc = logfs_crc32(oh, sizeof(*oh) - 4, 4);
449 if (crc != oh->crc) {
450 printk(KERN_ERR"LOGFS: header crc error at %llx: expected %x, "
451 "got %x\n", ofs, be32_to_cpu(oh->crc),
452 be32_to_cpu(crc));
453 return -EIO;
454 }
455 return 0;
456}
457
458static void move_btree_to_page(struct inode *inode, struct page *page,
459 __be64 *data)
460{
461 struct super_block *sb = inode->i_sb;
462 struct logfs_super *super = logfs_super(sb);
463 struct btree_head128 *head = &super->s_object_alias_tree;
464 struct logfs_block *block;
465 struct object_alias_item *item, *next;
466
467 if (!(super->s_flags & LOGFS_SB_FLAG_OBJ_ALIAS))
468 return;
469
470 block = btree_remove128(head, inode->i_ino, page->index);
471 if (!block)
472 return;
473
474 log_blockmove("move_btree_to_page(%llx, %llx, %x)\n",
475 block->ino, block->bix, block->level);
476 list_for_each_entry_safe(item, next, &block->item_list, list) {
477 data[item->child_no] = item->val;
478 list_del(&item->list);
479 mempool_free(item, super->s_alias_pool);
480 }
481 block->page = page;
482 SetPagePrivate(page);
483 page->private = (unsigned long)block;
484 block->ops = &indirect_block_ops;
485 initialize_block_counters(page, block, data, 0);
486}
487
488/*
489 * This silences a false, yet annoying gcc warning. I hate it when my editor
490 * jumps into bitops.h each time I recompile this file.
491 * TODO: Complain to gcc folks about this and upgrade compiler.
492 */
493static unsigned long fnb(const unsigned long *addr,
494 unsigned long size, unsigned long offset)
495{
496 return find_next_bit(addr, size, offset);
497}
498
499void move_page_to_btree(struct page *page)
500{
501 struct logfs_block *block = logfs_block(page);
502 struct super_block *sb = block->sb;
503 struct logfs_super *super = logfs_super(sb);
504 struct object_alias_item *item;
505 unsigned long pos;
506 __be64 *child;
507 int err;
508
509 if (super->s_flags & LOGFS_SB_FLAG_SHUTDOWN) {
510 block->ops->free_block(sb, block);
511 return;
512 }
513 log_blockmove("move_page_to_btree(%llx, %llx, %x)\n",
514 block->ino, block->bix, block->level);
515 super->s_flags |= LOGFS_SB_FLAG_OBJ_ALIAS;
516
517 for (pos = 0; ; pos++) {
518 pos = fnb(block->alias_map, LOGFS_BLOCK_FACTOR, pos);
519 if (pos >= LOGFS_BLOCK_FACTOR)
520 break;
521
522 item = mempool_alloc(super->s_alias_pool, GFP_NOFS);
523 BUG_ON(!item); /* mempool empty */
524 memset(item, 0, sizeof(*item));
525
526 child = kmap_atomic(page, KM_USER0);
527 item->val = child[pos];
528 kunmap_atomic(child, KM_USER0);
529 item->child_no = pos;
530 list_add(&item->list, &block->item_list);
531 }
532 block->page = NULL;
533 ClearPagePrivate(page);
534 page->private = 0;
535 block->ops = &btree_block_ops;
536 err = alias_tree_insert(block->sb, block->ino, block->bix, block->level,
537 block);
538 BUG_ON(err); /* mempool empty */
539 ClearPageUptodate(page);
540}
541
542static int __logfs_segment_read(struct inode *inode, void *buf,
543 u64 ofs, u64 bix, level_t level)
544{
545 struct super_block *sb = inode->i_sb;
546 void *compressor_buf = logfs_super(sb)->s_compressed_je;
547 struct logfs_object_header oh;
548 __be32 crc;
549 u16 len;
550 int err, block_len;
551
552 block_len = obj_len(sb, obj_type(inode, level));
553 err = read_obj_header(sb, ofs, &oh);
554 if (err)
555 goto out_err;
556
557 err = -EIO;
558 if (be64_to_cpu(oh.ino) != inode->i_ino
559 || check_pos(sb, be64_to_cpu(oh.bix), bix, level)) {
560 printk(KERN_ERR"LOGFS: (ino, bix) don't match at %llx: "
561 "expected (%lx, %llx), got (%llx, %llx)\n",
562 ofs, inode->i_ino, bix,
563 be64_to_cpu(oh.ino), be64_to_cpu(oh.bix));
564 goto out_err;
565 }
566
567 len = be16_to_cpu(oh.len);
568
569 switch (oh.compr) {
570 case COMPR_NONE:
571 err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len, buf);
572 if (err)
573 goto out_err;
574 crc = logfs_crc32(buf, len, 0);
575 if (crc != oh.data_crc) {
576 printk(KERN_ERR"LOGFS: uncompressed data crc error at "
577 "%llx: expected %x, got %x\n", ofs,
578 be32_to_cpu(oh.data_crc),
579 be32_to_cpu(crc));
580 goto out_err;
581 }
582 break;
583 case COMPR_ZLIB:
584 mutex_lock(&logfs_super(sb)->s_journal_mutex);
585 err = wbuf_read(sb, ofs + LOGFS_OBJECT_HEADERSIZE, len,
586 compressor_buf);
587 if (err) {
588 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
589 goto out_err;
590 }
591 crc = logfs_crc32(compressor_buf, len, 0);
592 if (crc != oh.data_crc) {
593 printk(KERN_ERR"LOGFS: compressed data crc error at "
594 "%llx: expected %x, got %x\n", ofs,
595 be32_to_cpu(oh.data_crc),
596 be32_to_cpu(crc));
597 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
598 goto out_err;
599 }
600 err = logfs_uncompress(compressor_buf, buf, len, block_len);
601 mutex_unlock(&logfs_super(sb)->s_journal_mutex);
602 if (err) {
603 printk(KERN_ERR"LOGFS: uncompress error at %llx\n", ofs);
604 goto out_err;
605 }
606 break;
607 default:
608 LOGFS_BUG(sb);
609 err = -EIO;
610 goto out_err;
611 }
612 return 0;
613
614out_err:
615 logfs_set_ro(sb);
616 printk(KERN_ERR"LOGFS: device is read-only now\n");
617 LOGFS_BUG(sb);
618 return err;
619}
620
621/**
622 * logfs_segment_read - read data block from object store
623 * @inode: inode containing data
624 * @buf: data buffer
625 * @ofs: physical data offset
626 * @bix: block index
627 * @level: block level
628 *
629 * Returns 0 on success or a negative errno.
630 */
631int logfs_segment_read(struct inode *inode, struct page *page,
632 u64 ofs, u64 bix, level_t level)
633{
634 int err;
635 void *buf;
636
637 if (PageUptodate(page))
638 return 0;
639
640 ofs &= ~LOGFS_FULLY_POPULATED;
641
642 buf = kmap(page);
643 err = __logfs_segment_read(inode, buf, ofs, bix, level);
644 if (!err) {
645 move_btree_to_page(inode, page, buf);
646 SetPageUptodate(page);
647 }
648 kunmap(page);
649 log_segment("logfs_segment_read(%lx, %llx, %x) %llx (%d)\n",
650 inode->i_ino, bix, level, ofs, err);
651 return err;
652}
653
654int logfs_segment_delete(struct inode *inode, struct logfs_shadow *shadow)
655{
656 struct super_block *sb = inode->i_sb;
657 struct logfs_super *super = logfs_super(sb);
658 struct logfs_object_header h;
659 u16 len;
660 int err;
661
662 super->s_flags |= LOGFS_SB_FLAG_DIRTY;
663 BUG_ON(super->s_flags & LOGFS_SB_FLAG_SHUTDOWN);
664 BUG_ON(shadow->old_ofs & LOGFS_FULLY_POPULATED);
665 if (!shadow->old_ofs)
666 return 0;
667
668 log_segment("logfs_segment_delete(%llx, %llx, %x) %llx->%llx %x->%x\n",
669 shadow->ino, shadow->bix, shadow->gc_level,
670 shadow->old_ofs, shadow->new_ofs,
671 shadow->old_len, shadow->new_len);
672 err = read_obj_header(sb, shadow->old_ofs, &h);
673 LOGFS_BUG_ON(err, sb);
674 LOGFS_BUG_ON(be64_to_cpu(h.ino) != inode->i_ino, sb);
675 LOGFS_BUG_ON(check_pos(sb, shadow->bix, be64_to_cpu(h.bix),
676 shrink_level(shadow->gc_level)), sb);
677
678 if (shadow->gc_level == 0)
679 len = be16_to_cpu(h.len);
680 else
681 len = obj_len(sb, h.type);
682 shadow->old_len = len + sizeof(h);
683 return 0;
684}
685
686static void freeseg(struct super_block *sb, u32 segno)
687{
688 struct logfs_super *super = logfs_super(sb);
689 struct address_space *mapping = super->s_mapping_inode->i_mapping;
690 struct page *page;
691 u64 ofs, start, end;
692
693 start = dev_ofs(sb, segno, 0);
694 end = dev_ofs(sb, segno + 1, 0);
695 for (ofs = start; ofs < end; ofs += PAGE_SIZE) {
696 page = find_get_page(mapping, ofs >> PAGE_SHIFT);
697 if (!page)
698 continue;
699 ClearPagePrivate(page);
700 page_cache_release(page);
701 }
702}
703
704int logfs_open_area(struct logfs_area *area, size_t bytes)
705{
706 struct super_block *sb = area->a_sb;
707 struct logfs_super *super = logfs_super(sb);
708 int err, closed = 0;
709
710 if (area->a_is_open && area->a_used_bytes + bytes <= super->s_segsize)
711 return 0;
712
713 if (area->a_is_open) {
714 u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
715 u32 len = super->s_segsize - area->a_written_bytes;
716
717 log_gc("logfs_close_area(%x)\n", area->a_segno);
718 pad_wbuf(area, 1);
719 super->s_devops->writeseg(area->a_sb, ofs, len);
720 freeseg(sb, area->a_segno);
721 closed = 1;
722 }
723
724 area->a_used_bytes = 0;
725 area->a_written_bytes = 0;
726again:
727 area->a_ops->get_free_segment(area);
728 area->a_ops->get_erase_count(area);
729
730 log_gc("logfs_open_area(%x, %x)\n", area->a_segno, area->a_level);
731 err = area->a_ops->erase_segment(area);
732 if (err) {
733 printk(KERN_WARNING "LogFS: Error erasing segment %x\n",
734 area->a_segno);
735 logfs_mark_segment_bad(sb, area->a_segno);
736 goto again;
737 }
738 area->a_is_open = 1;
739 return closed;
740}
741
742void logfs_sync_area(struct logfs_area *area)
743{
744 struct super_block *sb = area->a_sb;
745 struct logfs_super *super = logfs_super(sb);
746 u64 ofs = dev_ofs(sb, area->a_segno, area->a_written_bytes);
747 u32 len = (area->a_used_bytes - area->a_written_bytes);
748
749 if (super->s_writesize)
750 len &= ~(super->s_writesize - 1);
751 if (len == 0)
752 return;
753 pad_wbuf(area, 0);
754 super->s_devops->writeseg(sb, ofs, len);
755 area->a_written_bytes += len;
756}
757
758void logfs_sync_segments(struct super_block *sb)
759{
760 struct logfs_super *super = logfs_super(sb);
761 int i;
762
763 for_each_area(i)
764 logfs_sync_area(super->s_area[i]);
765}
766
767/*
768 * Pick a free segment to be used for this area. Effectively takes a
769 * candidate from the free list (not really a candidate anymore).
770 */
771static void ostore_get_free_segment(struct logfs_area *area)
772{
773 struct super_block *sb = area->a_sb;
774 struct logfs_super *super = logfs_super(sb);
775
776 if (super->s_free_list.count == 0) {
777 printk(KERN_ERR"LOGFS: ran out of free segments\n");
778 LOGFS_BUG(sb);
779 }
780
781 area->a_segno = get_best_cand(sb, &super->s_free_list, NULL);
782}
783
784static void ostore_get_erase_count(struct logfs_area *area)
785{
786 struct logfs_segment_entry se;
787 u32 ec_level;
788
789 logfs_get_segment_entry(area->a_sb, area->a_segno, &se);
790 BUG_ON(se.ec_level == cpu_to_be32(BADSEG) ||
791 se.valid == cpu_to_be32(RESERVED));
792
793 ec_level = be32_to_cpu(se.ec_level);
794 area->a_erase_count = (ec_level >> 4) + 1;
795}
796
797static int ostore_erase_segment(struct logfs_area *area)
798{
799 struct super_block *sb = area->a_sb;
800 struct logfs_segment_header sh;
801 u64 ofs;
802 int err;
803
804 err = logfs_erase_segment(sb, area->a_segno, 0);
805 if (err)
806 return err;
807
808 sh.pad = 0;
809 sh.type = SEG_OSTORE;
810 sh.level = (__force u8)area->a_level;
811 sh.segno = cpu_to_be32(area->a_segno);
812 sh.ec = cpu_to_be32(area->a_erase_count);
813 sh.gec = cpu_to_be64(logfs_super(sb)->s_gec);
814 sh.crc = logfs_crc32(&sh, sizeof(sh), 4);
815
816 logfs_set_segment_erased(sb, area->a_segno, area->a_erase_count,
817 area->a_level);
818
819 ofs = dev_ofs(sb, area->a_segno, 0);
820 area->a_used_bytes = sizeof(sh);
821 logfs_buf_write(area, ofs, &sh, sizeof(sh));
822 return 0;
823}
824
825static const struct logfs_area_ops ostore_area_ops = {
826 .get_free_segment = ostore_get_free_segment,
827 .get_erase_count = ostore_get_erase_count,
828 .erase_segment = ostore_erase_segment,
829};
830
831static void free_area(struct logfs_area *area)
832{
833 if (area)
834 freeseg(area->a_sb, area->a_segno);
835 kfree(area);
836}
837
838static struct logfs_area *alloc_area(struct super_block *sb)
839{
840 struct logfs_area *area;
841
842 area = kzalloc(sizeof(*area), GFP_KERNEL);
843 if (!area)
844 return NULL;
845
846 area->a_sb = sb;
847 return area;
848}
849
850static void map_invalidatepage(struct page *page, unsigned long l)
851{
852 BUG();
853}
854
855static int map_releasepage(struct page *page, gfp_t g)
856{
857 /* Don't release these pages */
858 return 0;
859}
860
861static const struct address_space_operations mapping_aops = {
862 .invalidatepage = map_invalidatepage,
863 .releasepage = map_releasepage,
864 .set_page_dirty = __set_page_dirty_nobuffers,
865};
866
867int logfs_init_mapping(struct super_block *sb)
868{
869 struct logfs_super *super = logfs_super(sb);
870 struct address_space *mapping;
871 struct inode *inode;
872
873 inode = logfs_new_meta_inode(sb, LOGFS_INO_MAPPING);
874 if (IS_ERR(inode))
875 return PTR_ERR(inode);
876 super->s_mapping_inode = inode;
877 mapping = inode->i_mapping;
878 mapping->a_ops = &mapping_aops;
879 /* Would it be possible to use __GFP_HIGHMEM as well? */
880 mapping_set_gfp_mask(mapping, GFP_NOFS);
881 return 0;
882}
883
884int logfs_init_areas(struct super_block *sb)
885{
886 struct logfs_super *super = logfs_super(sb);
887 int i = -1;
888
889 super->s_alias_pool = mempool_create_kmalloc_pool(600,
890 sizeof(struct object_alias_item));
891 if (!super->s_alias_pool)
892 return -ENOMEM;
893
894 super->s_journal_area = alloc_area(sb);
895 if (!super->s_journal_area)
896 goto err;
897
898 for_each_area(i) {
899 super->s_area[i] = alloc_area(sb);
900 if (!super->s_area[i])
901 goto err;
902 super->s_area[i]->a_level = GC_LEVEL(i);
903 super->s_area[i]->a_ops = &ostore_area_ops;
904 }
905 btree_init_mempool128(&super->s_object_alias_tree,
906 super->s_btree_pool);
907 return 0;
908
909err:
910 for (i--; i >= 0; i--)
911 free_area(super->s_area[i]);
912 free_area(super->s_journal_area);
913 mempool_destroy(super->s_alias_pool);
914 return -ENOMEM;
915}
916
917void logfs_cleanup_areas(struct super_block *sb)
918{
919 struct logfs_super *super = logfs_super(sb);
920 int i;
921
922 btree_grim_visitor128(&super->s_object_alias_tree, 0, kill_alias);
923 for_each_area(i)
924 free_area(super->s_area[i]);
925 free_area(super->s_journal_area);
926 destroy_meta_inode(super->s_mapping_inode);
927}
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-26 20:02:15 -0500