2 * Copyright (C) 2005, 2006
3 * Avishay Traeger (avishay@gmail.com)
4 * Copyright (C) 2008, 2009
5 * Boaz Harrosh <bharrosh@panasas.com>
7 * Copyrights for code taken from ext2:
8 * Copyright (C) 1992, 1993, 1994, 1995
9 * Remy Card (card@masi.ibp.fr)
10 * Laboratoire MASI - Institut Blaise Pascal
11 * Universite Pierre et Marie Curie (Paris VI)
13 * linux/fs/minix/inode.c
14 * Copyright (C) 1991, 1992 Linus Torvalds
16 * This file is part of exofs.
18 * exofs is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation. Since it is based on ext2, and the only
21 * valid version of GPL for the Linux kernel is version 2, the only valid
22 * version of GPL for exofs is version 2.
24 * exofs is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
29 * You should have received a copy of the GNU General Public License
30 * along with exofs; if not, write to the Free Software
31 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include <linux/slab.h>
38 #define EXOFS_DBGMSG2(M...) do {} while (0)
40 unsigned exofs_max_io_pages(struct ore_layout
*layout
,
41 unsigned expected_pages
)
43 unsigned pages
= min_t(unsigned, expected_pages
,
44 layout
->max_io_length
/ PAGE_SIZE
);
50 struct exofs_sb_info
*sbi
;
52 unsigned expected_pages
;
53 struct ore_io_state
*ios
;
59 loff_t pg_first
; /* keep 64bit also in 32-arches */
60 bool read_4_write
; /* This means two things: that the read is sync
61 * And the pages should not be unlocked.
63 struct page
*that_locked_page
;
66 static void _pcol_init(struct page_collect
*pcol
, unsigned expected_pages
,
69 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
73 pcol
->expected_pages
= expected_pages
;
77 pcol
->alloc_pages
= 0;
81 pcol
->read_4_write
= false;
82 pcol
->that_locked_page
= NULL
;
85 static void _pcol_reset(struct page_collect
*pcol
)
87 pcol
->expected_pages
-= min(pcol
->nr_pages
, pcol
->expected_pages
);
90 pcol
->alloc_pages
= 0;
95 pcol
->that_locked_page
= NULL
;
97 /* this is probably the end of the loop but in writes
98 * it might not end here. don't be left with nothing
100 if (!pcol
->expected_pages
)
101 pcol
->expected_pages
=
102 exofs_max_io_pages(&pcol
->sbi
->layout
, ~0);
105 static int pcol_try_alloc(struct page_collect
*pcol
)
109 /* TODO: easily support bio chaining */
110 pages
= exofs_max_io_pages(&pcol
->sbi
->layout
, pcol
->expected_pages
);
112 for (; pages
; pages
>>= 1) {
113 pcol
->pages
= kmalloc(pages
* sizeof(struct page
*),
115 if (likely(pcol
->pages
)) {
116 pcol
->alloc_pages
= pages
;
121 EXOFS_ERR("Failed to kmalloc expected_pages=%u\n",
122 pcol
->expected_pages
);
126 static void pcol_free(struct page_collect
*pcol
)
132 ore_put_io_state(pcol
->ios
);
137 static int pcol_add_page(struct page_collect
*pcol
, struct page
*page
,
140 if (unlikely(pcol
->nr_pages
>= pcol
->alloc_pages
))
143 pcol
->pages
[pcol
->nr_pages
++] = page
;
148 enum {PAGE_WAS_NOT_IN_IO
= 17};
149 static int update_read_page(struct page
*page
, int ret
)
153 /* Everything is OK */
154 SetPageUptodate(page
);
156 ClearPageError(page
);
159 /* In this case we were trying to read something that wasn't on
160 * disk yet - return a page full of zeroes. This should be OK,
161 * because the object should be empty (if there was a write
162 * before this read, the read would be waiting with the page
164 clear_highpage(page
);
166 SetPageUptodate(page
);
168 ClearPageError(page
);
169 EXOFS_DBGMSG("recovered read error\n");
171 case PAGE_WAS_NOT_IN_IO
:
172 ret
= 0; /* recovered error */
180 static void update_write_page(struct page
*page
, int ret
)
182 if (unlikely(ret
== PAGE_WAS_NOT_IN_IO
))
183 return; /* don't pass start don't collect $200 */
186 mapping_set_error(page
->mapping
, ret
);
189 end_page_writeback(page
);
192 /* Called at the end of reads, to optionally unlock pages and update their
195 static int __readpages_done(struct page_collect
*pcol
)
200 int ret
= ore_check_io(pcol
->ios
, NULL
);
203 good_bytes
= pcol
->length
;
204 ret
= PAGE_WAS_NOT_IN_IO
;
209 EXOFS_DBGMSG2("readpages_done(0x%lx) good_bytes=0x%llx"
210 " length=0x%lx nr_pages=%u\n",
211 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
214 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
215 struct page
*page
= pcol
->pages
[i
];
216 struct inode
*inode
= page
->mapping
->host
;
219 if (inode
!= pcol
->inode
)
220 continue; /* osd might add more pages at end */
222 if (likely(length
< good_bytes
))
227 EXOFS_DBGMSG2(" readpages_done(0x%lx, 0x%lx) %s\n",
228 inode
->i_ino
, page
->index
,
229 page_stat
? "bad_bytes" : "good_bytes");
231 ret
= update_read_page(page
, page_stat
);
232 if (!pcol
->read_4_write
)
238 EXOFS_DBGMSG2("readpages_done END\n");
242 /* callback of async reads */
243 static void readpages_done(struct ore_io_state
*ios
, void *p
)
245 struct page_collect
*pcol
= p
;
247 __readpages_done(pcol
);
248 atomic_dec(&pcol
->sbi
->s_curr_pending
);
252 static void _unlock_pcol_pages(struct page_collect
*pcol
, int ret
, int rw
)
256 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
257 struct page
*page
= pcol
->pages
[i
];
260 update_read_page(page
, ret
);
262 update_write_page(page
, ret
);
268 static int _maybe_not_all_in_one_io(struct ore_io_state
*ios
,
269 struct page_collect
*pcol_src
, struct page_collect
*pcol
)
271 /* length was wrong or offset was not page aligned */
272 BUG_ON(pcol_src
->nr_pages
< ios
->nr_pages
);
274 if (pcol_src
->nr_pages
> ios
->nr_pages
) {
275 struct page
**src_page
;
276 unsigned pages_less
= pcol_src
->nr_pages
- ios
->nr_pages
;
277 unsigned long len_less
= pcol_src
->length
- ios
->length
;
281 /* This IO was trimmed */
282 pcol_src
->nr_pages
= ios
->nr_pages
;
283 pcol_src
->length
= ios
->length
;
285 /* Left over pages are passed to the next io */
286 pcol
->expected_pages
+= pages_less
;
287 pcol
->nr_pages
= pages_less
;
288 pcol
->length
= len_less
;
289 src_page
= pcol_src
->pages
+ pcol_src
->nr_pages
;
290 pcol
->pg_first
= (*src_page
)->index
;
292 ret
= pcol_try_alloc(pcol
);
296 for (i
= 0; i
< pages_less
; ++i
)
297 pcol
->pages
[i
] = *src_page
++;
299 EXOFS_DBGMSG("Length was adjusted nr_pages=0x%x "
300 "pages_less=0x%x expected_pages=0x%x "
301 "next_offset=0x%llx next_len=0x%lx\n",
302 pcol_src
->nr_pages
, pages_less
, pcol
->expected_pages
,
303 pcol
->pg_first
* PAGE_SIZE
, pcol
->length
);
308 static int read_exec(struct page_collect
*pcol
)
310 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
311 struct ore_io_state
*ios
;
312 struct page_collect
*pcol_copy
= NULL
;
319 int ret
= ore_get_rw_state(&pcol
->sbi
->layout
, &oi
->oc
, true,
320 pcol
->pg_first
<< PAGE_CACHE_SHIFT
,
321 pcol
->length
, &pcol
->ios
);
328 ios
->pages
= pcol
->pages
;
330 if (pcol
->read_4_write
) {
332 return __readpages_done(pcol
);
335 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
342 ios
->done
= readpages_done
;
343 ios
->private = pcol_copy
;
345 /* pages ownership was passed to pcol_copy */
348 ret
= _maybe_not_all_in_one_io(ios
, pcol_copy
, pcol
);
352 EXOFS_DBGMSG2("read_exec(0x%lx) offset=0x%llx length=0x%llx\n",
353 pcol
->inode
->i_ino
, _LLU(ios
->offset
), _LLU(ios
->length
));
359 atomic_inc(&pcol
->sbi
->s_curr_pending
);
364 if (!pcol_copy
) /* Failed before ownership transfer */
366 _unlock_pcol_pages(pcol_copy
, ret
, READ
);
367 pcol_free(pcol_copy
);
373 /* readpage_strip is called either directly from readpage() or by the VFS from
374 * within read_cache_pages(), to add one more page to be read. It will try to
375 * collect as many contiguous pages as posible. If a discontinuity is
376 * encountered, or it runs out of resources, it will submit the previous segment
377 * and will start a new collection. Eventually caller must submit the last
378 * segment if present.
380 static int readpage_strip(void *data
, struct page
*page
)
382 struct page_collect
*pcol
= data
;
383 struct inode
*inode
= pcol
->inode
;
384 struct exofs_i_info
*oi
= exofs_i(inode
);
385 loff_t i_size
= i_size_read(inode
);
386 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
390 BUG_ON(!PageLocked(page
));
392 /* FIXME: Just for debugging, will be removed */
393 if (PageUptodate(page
))
394 EXOFS_ERR("PageUptodate(0x%lx, 0x%lx)\n", pcol
->inode
->i_ino
,
397 pcol
->that_locked_page
= page
;
399 if (page
->index
< end_index
)
400 len
= PAGE_CACHE_SIZE
;
401 else if (page
->index
== end_index
)
402 len
= i_size
& ~PAGE_CACHE_MASK
;
406 if (!len
|| !obj_created(oi
)) {
407 /* this will be out of bounds, or doesn't exist yet.
408 * Current page is cleared and the request is split
410 clear_highpage(page
);
412 SetPageUptodate(page
);
414 ClearPageError(page
);
416 if (!pcol
->read_4_write
)
418 EXOFS_DBGMSG("readpage_strip(0x%lx) empty page len=%zx "
419 "read_4_write=%d index=0x%lx end_index=0x%lx "
420 "splitting\n", inode
->i_ino
, len
,
421 pcol
->read_4_write
, page
->index
, end_index
);
423 return read_exec(pcol
);
428 if (unlikely(pcol
->pg_first
== -1)) {
429 pcol
->pg_first
= page
->index
;
430 } else if (unlikely((pcol
->pg_first
+ pcol
->nr_pages
) !=
432 /* Discontinuity detected, split the request */
433 ret
= read_exec(pcol
);
440 ret
= pcol_try_alloc(pcol
);
445 if (len
!= PAGE_CACHE_SIZE
)
446 zero_user(page
, len
, PAGE_CACHE_SIZE
- len
);
448 EXOFS_DBGMSG2(" readpage_strip(0x%lx, 0x%lx) len=0x%zx\n",
449 inode
->i_ino
, page
->index
, len
);
451 ret
= pcol_add_page(pcol
, page
, len
);
453 EXOFS_DBGMSG2("Failed pcol_add_page pages[i]=%p "
454 "this_len=0x%zx nr_pages=%u length=0x%lx\n",
455 page
, len
, pcol
->nr_pages
, pcol
->length
);
457 /* split the request, and start again with current page */
458 ret
= read_exec(pcol
);
468 /* SetPageError(page); ??? */
473 static int exofs_readpages(struct file
*file
, struct address_space
*mapping
,
474 struct list_head
*pages
, unsigned nr_pages
)
476 struct page_collect pcol
;
479 _pcol_init(&pcol
, nr_pages
, mapping
->host
);
481 ret
= read_cache_pages(mapping
, pages
, readpage_strip
, &pcol
);
483 EXOFS_ERR("read_cache_pages => %d\n", ret
);
487 ret
= read_exec(&pcol
);
491 return read_exec(&pcol
);
494 static int _readpage(struct page
*page
, bool read_4_write
)
496 struct page_collect pcol
;
499 _pcol_init(&pcol
, 1, page
->mapping
->host
);
501 pcol
.read_4_write
= read_4_write
;
502 ret
= readpage_strip(&pcol
, page
);
504 EXOFS_ERR("_readpage => %d\n", ret
);
508 return read_exec(&pcol
);
512 * We don't need the file
514 static int exofs_readpage(struct file
*file
, struct page
*page
)
516 return _readpage(page
, false);
519 /* Callback for osd_write. All writes are asynchronous */
520 static void writepages_done(struct ore_io_state
*ios
, void *p
)
522 struct page_collect
*pcol
= p
;
526 int ret
= ore_check_io(ios
, NULL
);
528 atomic_dec(&pcol
->sbi
->s_curr_pending
);
531 good_bytes
= pcol
->length
;
532 ret
= PAGE_WAS_NOT_IN_IO
;
537 EXOFS_DBGMSG2("writepages_done(0x%lx) good_bytes=0x%llx"
538 " length=0x%lx nr_pages=%u\n",
539 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
542 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
543 struct page
*page
= pcol
->pages
[i
];
544 struct inode
*inode
= page
->mapping
->host
;
547 if (inode
!= pcol
->inode
)
548 continue; /* osd might add more pages to a bio */
550 if (likely(length
< good_bytes
))
555 update_write_page(page
, page_stat
);
557 EXOFS_DBGMSG2(" writepages_done(0x%lx, 0x%lx) status=%d\n",
558 inode
->i_ino
, page
->index
, page_stat
);
565 EXOFS_DBGMSG2("writepages_done END\n");
568 static struct page
*__r4w_get_page(void *priv
, u64 offset
, bool *uptodate
)
570 struct page_collect
*pcol
= priv
;
571 pgoff_t index
= offset
/ PAGE_SIZE
;
573 if (!pcol
->that_locked_page
||
574 (pcol
->that_locked_page
->index
!= index
)) {
576 loff_t i_size
= i_size_read(pcol
->inode
);
578 if (offset
>= i_size
) {
580 EXOFS_DBGMSG2("offset >= i_size index=0x%lx\n", index
);
584 page
= find_get_page(pcol
->inode
->i_mapping
, index
);
586 page
= find_or_create_page(pcol
->inode
->i_mapping
,
588 if (unlikely(!page
)) {
589 EXOFS_DBGMSG("grab_cache_page Failed "
590 "index=0x%llx\n", _LLU(index
));
595 if (PageDirty(page
) || PageWriteback(page
))
598 *uptodate
= PageUptodate(page
);
599 EXOFS_DBGMSG2("index=0x%lx uptodate=%d\n", index
, *uptodate
);
602 EXOFS_DBGMSG2("YES that_locked_page index=0x%lx\n",
603 pcol
->that_locked_page
->index
);
605 return pcol
->that_locked_page
;
609 static void __r4w_put_page(void *priv
, struct page
*page
)
611 struct page_collect
*pcol
= priv
;
613 if ((pcol
->that_locked_page
!= page
) && (ZERO_PAGE(0) != page
)) {
614 EXOFS_DBGMSG2("index=0x%lx\n", page
->index
);
615 page_cache_release(page
);
618 EXOFS_DBGMSG2("that_locked_page index=0x%lx\n",
619 ZERO_PAGE(0) == page
? -1 : page
->index
);
622 static const struct _ore_r4w_op _r4w_op
= {
623 .get_page
= &__r4w_get_page
,
624 .put_page
= &__r4w_put_page
,
627 static int write_exec(struct page_collect
*pcol
)
629 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
630 struct ore_io_state
*ios
;
631 struct page_collect
*pcol_copy
= NULL
;
638 ret
= ore_get_rw_state(&pcol
->sbi
->layout
, &oi
->oc
, false,
639 pcol
->pg_first
<< PAGE_CACHE_SHIFT
,
640 pcol
->length
, &pcol
->ios
);
644 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
646 EXOFS_ERR("write_exec: Failed to kmalloc(pcol)\n");
654 ios
->pages
= pcol_copy
->pages
;
655 ios
->done
= writepages_done
;
657 ios
->private = pcol_copy
;
659 /* pages ownership was passed to pcol_copy */
662 ret
= _maybe_not_all_in_one_io(ios
, pcol_copy
, pcol
);
666 EXOFS_DBGMSG2("write_exec(0x%lx) offset=0x%llx length=0x%llx\n",
667 pcol
->inode
->i_ino
, _LLU(ios
->offset
), _LLU(ios
->length
));
669 ret
= ore_write(ios
);
671 EXOFS_ERR("write_exec: ore_write() Failed\n");
675 atomic_inc(&pcol
->sbi
->s_curr_pending
);
679 if (!pcol_copy
) /* Failed before ownership transfer */
681 _unlock_pcol_pages(pcol_copy
, ret
, WRITE
);
682 pcol_free(pcol_copy
);
688 /* writepage_strip is called either directly from writepage() or by the VFS from
689 * within write_cache_pages(), to add one more page to be written to storage.
690 * It will try to collect as many contiguous pages as possible. If a
691 * discontinuity is encountered or it runs out of resources it will submit the
692 * previous segment and will start a new collection.
693 * Eventually caller must submit the last segment if present.
695 static int writepage_strip(struct page
*page
,
696 struct writeback_control
*wbc_unused
, void *data
)
698 struct page_collect
*pcol
= data
;
699 struct inode
*inode
= pcol
->inode
;
700 struct exofs_i_info
*oi
= exofs_i(inode
);
701 loff_t i_size
= i_size_read(inode
);
702 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
706 BUG_ON(!PageLocked(page
));
708 ret
= wait_obj_created(oi
);
712 if (page
->index
< end_index
)
713 /* in this case, the page is within the limits of the file */
714 len
= PAGE_CACHE_SIZE
;
716 len
= i_size
& ~PAGE_CACHE_MASK
;
718 if (page
->index
> end_index
|| !len
) {
719 /* in this case, the page is outside the limits
720 * (truncate in progress)
722 ret
= write_exec(pcol
);
726 ClearPageError(page
);
728 EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) "
729 "outside the limits\n",
730 inode
->i_ino
, page
->index
);
737 if (unlikely(pcol
->pg_first
== -1)) {
738 pcol
->pg_first
= page
->index
;
739 } else if (unlikely((pcol
->pg_first
+ pcol
->nr_pages
) !=
741 /* Discontinuity detected, split the request */
742 ret
= write_exec(pcol
);
746 EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) Discontinuity\n",
747 inode
->i_ino
, page
->index
);
752 ret
= pcol_try_alloc(pcol
);
757 EXOFS_DBGMSG2(" writepage_strip(0x%lx, 0x%lx) len=0x%zx\n",
758 inode
->i_ino
, page
->index
, len
);
760 ret
= pcol_add_page(pcol
, page
, len
);
762 EXOFS_DBGMSG2("Failed pcol_add_page "
763 "nr_pages=%u total_length=0x%lx\n",
764 pcol
->nr_pages
, pcol
->length
);
766 /* split the request, next loop will start again */
767 ret
= write_exec(pcol
);
769 EXOFS_DBGMSG("write_exec failed => %d", ret
);
776 BUG_ON(PageWriteback(page
));
777 set_page_writeback(page
);
782 EXOFS_DBGMSG("Error: writepage_strip(0x%lx, 0x%lx)=>%d\n",
783 inode
->i_ino
, page
->index
, ret
);
784 set_bit(AS_EIO
, &page
->mapping
->flags
);
789 static int exofs_writepages(struct address_space
*mapping
,
790 struct writeback_control
*wbc
)
792 struct page_collect pcol
;
793 long start
, end
, expected_pages
;
796 start
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
797 end
= (wbc
->range_end
== LLONG_MAX
) ?
798 start
+ mapping
->nrpages
:
799 wbc
->range_end
>> PAGE_CACHE_SHIFT
;
802 expected_pages
= end
- start
+ 1;
804 expected_pages
= mapping
->nrpages
;
806 if (expected_pages
< 32L)
807 expected_pages
= 32L;
809 EXOFS_DBGMSG2("inode(0x%lx) wbc->start=0x%llx wbc->end=0x%llx "
810 "nrpages=%lu start=0x%lx end=0x%lx expected_pages=%ld\n",
811 mapping
->host
->i_ino
, wbc
->range_start
, wbc
->range_end
,
812 mapping
->nrpages
, start
, end
, expected_pages
);
814 _pcol_init(&pcol
, expected_pages
, mapping
->host
);
816 ret
= write_cache_pages(mapping
, wbc
, writepage_strip
, &pcol
);
818 EXOFS_ERR("write_cache_pages => %d\n", ret
);
822 ret
= write_exec(&pcol
);
826 if (wbc
->sync_mode
== WB_SYNC_ALL
) {
827 return write_exec(&pcol
); /* pump the last reminder */
828 } else if (pcol
.nr_pages
) {
829 /* not SYNC let the reminder join the next writeout */
832 for (i
= 0; i
< pcol
.nr_pages
; i
++) {
833 struct page
*page
= pcol
.pages
[i
];
835 end_page_writeback(page
);
836 set_page_dirty(page
);
844 static int exofs_writepage(struct page *page, struct writeback_control *wbc)
846 struct page_collect pcol;
849 _pcol_init(&pcol, 1, page->mapping->host);
851 ret = writepage_strip(page, NULL, &pcol);
853 EXOFS_ERR("exofs_writepage => %d\n", ret);
857 return write_exec(&pcol);
860 /* i_mutex held using inode->i_size directly */
861 static void _write_failed(struct inode
*inode
, loff_t to
)
863 if (to
> inode
->i_size
)
864 truncate_pagecache(inode
, inode
->i_size
);
867 int exofs_write_begin(struct file
*file
, struct address_space
*mapping
,
868 loff_t pos
, unsigned len
, unsigned flags
,
869 struct page
**pagep
, void **fsdata
)
876 ret
= simple_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
879 EXOFS_DBGMSG("simple_write_begin failed\n");
886 /* read modify write */
887 if (!PageUptodate(page
) && (len
!= PAGE_CACHE_SIZE
)) {
888 loff_t i_size
= i_size_read(mapping
->host
);
889 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
892 if (page
->index
< end_index
)
893 rlen
= PAGE_CACHE_SIZE
;
894 else if (page
->index
== end_index
)
895 rlen
= i_size
& ~PAGE_CACHE_MASK
;
900 clear_highpage(page
);
901 SetPageUptodate(page
);
905 ret
= _readpage(page
, true);
907 /*SetPageError was done by _readpage. Is it ok?*/
909 EXOFS_DBGMSG("__readpage failed\n");
914 _write_failed(mapping
->host
, pos
+ len
);
919 static int exofs_write_begin_export(struct file
*file
,
920 struct address_space
*mapping
,
921 loff_t pos
, unsigned len
, unsigned flags
,
922 struct page
**pagep
, void **fsdata
)
926 return exofs_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
930 static int exofs_write_end(struct file
*file
, struct address_space
*mapping
,
931 loff_t pos
, unsigned len
, unsigned copied
,
932 struct page
*page
, void *fsdata
)
934 struct inode
*inode
= mapping
->host
;
935 /* According to comment in simple_write_end i_mutex is held */
936 loff_t i_size
= inode
->i_size
;
939 ret
= simple_write_end(file
, mapping
,pos
, len
, copied
, page
, fsdata
);
941 _write_failed(inode
, pos
+ len
);
943 /* TODO: once simple_write_end marks inode dirty remove */
944 if (i_size
!= inode
->i_size
)
945 mark_inode_dirty(inode
);
949 static int exofs_releasepage(struct page
*page
, gfp_t gfp
)
951 EXOFS_DBGMSG("page 0x%lx\n", page
->index
);
956 static void exofs_invalidatepage(struct page
*page
, unsigned int offset
,
959 EXOFS_DBGMSG("page 0x%lx offset 0x%x length 0x%x\n",
960 page
->index
, offset
, length
);
965 /* TODO: Should be easy enough to do proprly */
966 static ssize_t
exofs_direct_IO(int rw
, struct kiocb
*iocb
,
967 const struct iovec
*iov
, loff_t offset
, unsigned long nr_segs
)
972 const struct address_space_operations exofs_aops
= {
973 .readpage
= exofs_readpage
,
974 .readpages
= exofs_readpages
,
976 .writepages
= exofs_writepages
,
977 .write_begin
= exofs_write_begin_export
,
978 .write_end
= exofs_write_end
,
979 .releasepage
= exofs_releasepage
,
980 .set_page_dirty
= __set_page_dirty_nobuffers
,
981 .invalidatepage
= exofs_invalidatepage
,
983 /* Not implemented Yet */
984 .bmap
= NULL
, /* TODO: use osd's OSD_ACT_READ_MAP */
985 .direct_IO
= exofs_direct_IO
,
987 /* With these NULL has special meaning or default is not exported */
990 .launder_page
= NULL
,
991 .is_partially_uptodate
= NULL
,
992 .error_remove_page
= NULL
,
995 /******************************************************************************
997 *****************************************************************************/
1000 * Test whether an inode is a fast symlink.
1002 static inline int exofs_inode_is_fast_symlink(struct inode
*inode
)
1004 struct exofs_i_info
*oi
= exofs_i(inode
);
1006 return S_ISLNK(inode
->i_mode
) && (oi
->i_data
[0] != 0);
1009 static int _do_truncate(struct inode
*inode
, loff_t newsize
)
1011 struct exofs_i_info
*oi
= exofs_i(inode
);
1012 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
1015 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
1017 ret
= ore_truncate(&sbi
->layout
, &oi
->oc
, (u64
)newsize
);
1019 truncate_setsize(inode
, newsize
);
1021 EXOFS_DBGMSG2("(0x%lx) size=0x%llx ret=>%d\n",
1022 inode
->i_ino
, newsize
, ret
);
1027 * Set inode attributes - update size attribute on OSD if needed,
1028 * otherwise just call generic functions.
1030 int exofs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
1032 struct inode
*inode
= dentry
->d_inode
;
1035 /* if we are about to modify an object, and it hasn't been
1038 error
= wait_obj_created(exofs_i(inode
));
1039 if (unlikely(error
))
1042 error
= inode_change_ok(inode
, iattr
);
1043 if (unlikely(error
))
1046 if ((iattr
->ia_valid
& ATTR_SIZE
) &&
1047 iattr
->ia_size
!= i_size_read(inode
)) {
1048 error
= _do_truncate(inode
, iattr
->ia_size
);
1049 if (unlikely(error
))
1053 setattr_copy(inode
, iattr
);
1054 mark_inode_dirty(inode
);
1058 static const struct osd_attr g_attr_inode_file_layout
= ATTR_DEF(
1059 EXOFS_APAGE_FS_DATA
,
1060 EXOFS_ATTR_INODE_FILE_LAYOUT
,
1062 static const struct osd_attr g_attr_inode_dir_layout
= ATTR_DEF(
1063 EXOFS_APAGE_FS_DATA
,
1064 EXOFS_ATTR_INODE_DIR_LAYOUT
,
1068 * Read the Linux inode info from the OSD, and return it as is. In exofs the
1069 * inode info is in an application specific page/attribute of the osd-object.
1071 static int exofs_get_inode(struct super_block
*sb
, struct exofs_i_info
*oi
,
1072 struct exofs_fcb
*inode
)
1074 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1075 struct osd_attr attrs
[] = {
1076 [0] = g_attr_inode_data
,
1077 [1] = g_attr_inode_file_layout
,
1078 [2] = g_attr_inode_dir_layout
,
1080 struct ore_io_state
*ios
;
1081 struct exofs_on_disk_inode_layout
*layout
;
1084 ret
= ore_get_io_state(&sbi
->layout
, &oi
->oc
, &ios
);
1085 if (unlikely(ret
)) {
1086 EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__
);
1090 attrs
[1].len
= exofs_on_disk_inode_layout_size(sbi
->oc
.numdevs
);
1091 attrs
[2].len
= exofs_on_disk_inode_layout_size(sbi
->oc
.numdevs
);
1093 ios
->in_attr
= attrs
;
1094 ios
->in_attr_len
= ARRAY_SIZE(attrs
);
1096 ret
= ore_read(ios
);
1097 if (unlikely(ret
)) {
1098 EXOFS_ERR("object(0x%llx) corrupted, return empty file=>%d\n",
1099 _LLU(oi
->one_comp
.obj
.id
), ret
);
1100 memset(inode
, 0, sizeof(*inode
));
1101 inode
->i_mode
= 0040000 | (0777 & ~022);
1102 /* If object is lost on target we might as well enable it's
1109 ret
= extract_attr_from_ios(ios
, &attrs
[0]);
1111 EXOFS_ERR("%s: extract_attr 0 of inode failed\n", __func__
);
1114 WARN_ON(attrs
[0].len
!= EXOFS_INO_ATTR_SIZE
);
1115 memcpy(inode
, attrs
[0].val_ptr
, EXOFS_INO_ATTR_SIZE
);
1117 ret
= extract_attr_from_ios(ios
, &attrs
[1]);
1119 EXOFS_ERR("%s: extract_attr 1 of inode failed\n", __func__
);
1123 layout
= attrs
[1].val_ptr
;
1124 if (layout
->gen_func
!= cpu_to_le16(LAYOUT_MOVING_WINDOW
)) {
1125 EXOFS_ERR("%s: unsupported files layout %d\n",
1126 __func__
, layout
->gen_func
);
1132 ret
= extract_attr_from_ios(ios
, &attrs
[2]);
1134 EXOFS_ERR("%s: extract_attr 2 of inode failed\n", __func__
);
1138 layout
= attrs
[2].val_ptr
;
1139 if (layout
->gen_func
!= cpu_to_le16(LAYOUT_MOVING_WINDOW
)) {
1140 EXOFS_ERR("%s: unsupported meta-data layout %d\n",
1141 __func__
, layout
->gen_func
);
1148 ore_put_io_state(ios
);
1152 static void __oi_init(struct exofs_i_info
*oi
)
1154 init_waitqueue_head(&oi
->i_wq
);
1158 * Fill in an inode read from the OSD and set it up for use
1160 struct inode
*exofs_iget(struct super_block
*sb
, unsigned long ino
)
1162 struct exofs_i_info
*oi
;
1163 struct exofs_fcb fcb
;
1164 struct inode
*inode
;
1167 inode
= iget_locked(sb
, ino
);
1169 return ERR_PTR(-ENOMEM
);
1170 if (!(inode
->i_state
& I_NEW
))
1172 oi
= exofs_i(inode
);
1174 exofs_init_comps(&oi
->oc
, &oi
->one_comp
, sb
->s_fs_info
,
1175 exofs_oi_objno(oi
));
1177 /* read the inode from the osd */
1178 ret
= exofs_get_inode(sb
, oi
, &fcb
);
1182 set_obj_created(oi
);
1184 /* copy stuff from on-disk struct to in-memory struct */
1185 inode
->i_mode
= le16_to_cpu(fcb
.i_mode
);
1186 i_uid_write(inode
, le32_to_cpu(fcb
.i_uid
));
1187 i_gid_write(inode
, le32_to_cpu(fcb
.i_gid
));
1188 set_nlink(inode
, le16_to_cpu(fcb
.i_links_count
));
1189 inode
->i_ctime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_ctime
);
1190 inode
->i_atime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_atime
);
1191 inode
->i_mtime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_mtime
);
1192 inode
->i_ctime
.tv_nsec
=
1193 inode
->i_atime
.tv_nsec
= inode
->i_mtime
.tv_nsec
= 0;
1194 oi
->i_commit_size
= le64_to_cpu(fcb
.i_size
);
1195 i_size_write(inode
, oi
->i_commit_size
);
1196 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
1197 inode
->i_generation
= le32_to_cpu(fcb
.i_generation
);
1199 oi
->i_dir_start_lookup
= 0;
1201 if ((inode
->i_nlink
== 0) && (inode
->i_mode
== 0)) {
1206 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1209 old_decode_dev(le32_to_cpu(fcb
.i_data
[0]));
1212 new_decode_dev(le32_to_cpu(fcb
.i_data
[1]));
1214 memcpy(oi
->i_data
, fcb
.i_data
, sizeof(fcb
.i_data
));
1217 inode
->i_mapping
->backing_dev_info
= sb
->s_bdi
;
1218 if (S_ISREG(inode
->i_mode
)) {
1219 inode
->i_op
= &exofs_file_inode_operations
;
1220 inode
->i_fop
= &exofs_file_operations
;
1221 inode
->i_mapping
->a_ops
= &exofs_aops
;
1222 } else if (S_ISDIR(inode
->i_mode
)) {
1223 inode
->i_op
= &exofs_dir_inode_operations
;
1224 inode
->i_fop
= &exofs_dir_operations
;
1225 inode
->i_mapping
->a_ops
= &exofs_aops
;
1226 } else if (S_ISLNK(inode
->i_mode
)) {
1227 if (exofs_inode_is_fast_symlink(inode
))
1228 inode
->i_op
= &exofs_fast_symlink_inode_operations
;
1230 inode
->i_op
= &exofs_symlink_inode_operations
;
1231 inode
->i_mapping
->a_ops
= &exofs_aops
;
1234 inode
->i_op
= &exofs_special_inode_operations
;
1236 init_special_inode(inode
, inode
->i_mode
,
1237 old_decode_dev(le32_to_cpu(fcb
.i_data
[0])));
1239 init_special_inode(inode
, inode
->i_mode
,
1240 new_decode_dev(le32_to_cpu(fcb
.i_data
[1])));
1243 unlock_new_inode(inode
);
1248 return ERR_PTR(ret
);
1251 int __exofs_wait_obj_created(struct exofs_i_info
*oi
)
1253 if (!obj_created(oi
)) {
1254 EXOFS_DBGMSG("!obj_created\n");
1255 BUG_ON(!obj_2bcreated(oi
));
1256 wait_event(oi
->i_wq
, obj_created(oi
));
1257 EXOFS_DBGMSG("wait_event done\n");
1259 return unlikely(is_bad_inode(&oi
->vfs_inode
)) ? -EIO
: 0;
1263 * Callback function from exofs_new_inode(). The important thing is that we
1264 * set the obj_created flag so that other methods know that the object exists on
1267 static void create_done(struct ore_io_state
*ios
, void *p
)
1269 struct inode
*inode
= p
;
1270 struct exofs_i_info
*oi
= exofs_i(inode
);
1271 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
1274 ret
= ore_check_io(ios
, NULL
);
1275 ore_put_io_state(ios
);
1277 atomic_dec(&sbi
->s_curr_pending
);
1279 if (unlikely(ret
)) {
1280 EXOFS_ERR("object=0x%llx creation failed in pid=0x%llx",
1281 _LLU(exofs_oi_objno(oi
)),
1282 _LLU(oi
->one_comp
.obj
.partition
));
1283 /*TODO: When FS is corrupted creation can fail, object already
1284 * exist. Get rid of this asynchronous creation, if exist
1285 * increment the obj counter and try the next object. Until we
1286 * succeed. All these dangling objects will be made into lost
1287 * files by chkfs.exofs
1291 set_obj_created(oi
);
1297 * Set up a new inode and create an object for it on the OSD
1299 struct inode
*exofs_new_inode(struct inode
*dir
, umode_t mode
)
1301 struct super_block
*sb
= dir
->i_sb
;
1302 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1303 struct inode
*inode
;
1304 struct exofs_i_info
*oi
;
1305 struct ore_io_state
*ios
;
1308 inode
= new_inode(sb
);
1310 return ERR_PTR(-ENOMEM
);
1312 oi
= exofs_i(inode
);
1315 set_obj_2bcreated(oi
);
1317 inode
->i_mapping
->backing_dev_info
= sb
->s_bdi
;
1318 inode_init_owner(inode
, dir
, mode
);
1319 inode
->i_ino
= sbi
->s_nextid
++;
1320 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
1321 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
1322 oi
->i_commit_size
= inode
->i_size
= 0;
1323 spin_lock(&sbi
->s_next_gen_lock
);
1324 inode
->i_generation
= sbi
->s_next_generation
++;
1325 spin_unlock(&sbi
->s_next_gen_lock
);
1326 insert_inode_hash(inode
);
1328 exofs_init_comps(&oi
->oc
, &oi
->one_comp
, sb
->s_fs_info
,
1329 exofs_oi_objno(oi
));
1330 exofs_sbi_write_stats(sbi
); /* Make sure new sbi->s_nextid is on disk */
1332 mark_inode_dirty(inode
);
1334 ret
= ore_get_io_state(&sbi
->layout
, &oi
->oc
, &ios
);
1335 if (unlikely(ret
)) {
1336 EXOFS_ERR("exofs_new_inode: ore_get_io_state failed\n");
1337 return ERR_PTR(ret
);
1340 ios
->done
= create_done
;
1341 ios
->private = inode
;
1343 ret
= ore_create(ios
);
1345 ore_put_io_state(ios
);
1346 return ERR_PTR(ret
);
1348 atomic_inc(&sbi
->s_curr_pending
);
1354 * struct to pass two arguments to update_inode's callback
1356 struct updatei_args
{
1357 struct exofs_sb_info
*sbi
;
1358 struct exofs_fcb fcb
;
1362 * Callback function from exofs_update_inode().
1364 static void updatei_done(struct ore_io_state
*ios
, void *p
)
1366 struct updatei_args
*args
= p
;
1368 ore_put_io_state(ios
);
1370 atomic_dec(&args
->sbi
->s_curr_pending
);
1376 * Write the inode to the OSD. Just fill up the struct, and set the attribute
1377 * synchronously or asynchronously depending on the do_sync flag.
1379 static int exofs_update_inode(struct inode
*inode
, int do_sync
)
1381 struct exofs_i_info
*oi
= exofs_i(inode
);
1382 struct super_block
*sb
= inode
->i_sb
;
1383 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1384 struct ore_io_state
*ios
;
1385 struct osd_attr attr
;
1386 struct exofs_fcb
*fcb
;
1387 struct updatei_args
*args
;
1390 args
= kzalloc(sizeof(*args
), GFP_KERNEL
);
1392 EXOFS_DBGMSG("Failed kzalloc of args\n");
1398 fcb
->i_mode
= cpu_to_le16(inode
->i_mode
);
1399 fcb
->i_uid
= cpu_to_le32(i_uid_read(inode
));
1400 fcb
->i_gid
= cpu_to_le32(i_gid_read(inode
));
1401 fcb
->i_links_count
= cpu_to_le16(inode
->i_nlink
);
1402 fcb
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
1403 fcb
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
1404 fcb
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
1405 oi
->i_commit_size
= i_size_read(inode
);
1406 fcb
->i_size
= cpu_to_le64(oi
->i_commit_size
);
1407 fcb
->i_generation
= cpu_to_le32(inode
->i_generation
);
1409 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1410 if (old_valid_dev(inode
->i_rdev
)) {
1412 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
1417 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
1421 memcpy(fcb
->i_data
, oi
->i_data
, sizeof(fcb
->i_data
));
1423 ret
= ore_get_io_state(&sbi
->layout
, &oi
->oc
, &ios
);
1424 if (unlikely(ret
)) {
1425 EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__
);
1429 attr
= g_attr_inode_data
;
1431 ios
->out_attr_len
= 1;
1432 ios
->out_attr
= &attr
;
1434 wait_obj_created(oi
);
1438 ios
->done
= updatei_done
;
1439 ios
->private = args
;
1442 ret
= ore_write(ios
);
1443 if (!do_sync
&& !ret
) {
1444 atomic_inc(&sbi
->s_curr_pending
);
1445 goto out
; /* deallocation in updatei_done */
1448 ore_put_io_state(ios
);
1452 EXOFS_DBGMSG("(0x%lx) do_sync=%d ret=>%d\n",
1453 inode
->i_ino
, do_sync
, ret
);
1457 int exofs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1459 /* FIXME: fix fsync and use wbc->sync_mode == WB_SYNC_ALL */
1460 return exofs_update_inode(inode
, 1);
1464 * Callback function from exofs_delete_inode() - don't have much cleaning up to
1467 static void delete_done(struct ore_io_state
*ios
, void *p
)
1469 struct exofs_sb_info
*sbi
= p
;
1471 ore_put_io_state(ios
);
1473 atomic_dec(&sbi
->s_curr_pending
);
1477 * Called when the refcount of an inode reaches zero. We remove the object
1478 * from the OSD here. We make sure the object was created before we try and
1481 void exofs_evict_inode(struct inode
*inode
)
1483 struct exofs_i_info
*oi
= exofs_i(inode
);
1484 struct super_block
*sb
= inode
->i_sb
;
1485 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1486 struct ore_io_state
*ios
;
1489 truncate_inode_pages(&inode
->i_data
, 0);
1491 /* TODO: should do better here */
1492 if (inode
->i_nlink
|| is_bad_inode(inode
))
1498 /* if we are deleting an obj that hasn't been created yet, wait.
1499 * This also makes sure that create_done cannot be called with an
1500 * already evicted inode.
1502 wait_obj_created(oi
);
1503 /* ignore the error, attempt a remove anyway */
1505 /* Now Remove the OSD objects */
1506 ret
= ore_get_io_state(&sbi
->layout
, &oi
->oc
, &ios
);
1507 if (unlikely(ret
)) {
1508 EXOFS_ERR("%s: ore_get_io_state failed\n", __func__
);
1512 ios
->done
= delete_done
;
1515 ret
= ore_remove(ios
);
1517 EXOFS_ERR("%s: ore_remove failed\n", __func__
);
1518 ore_put_io_state(ios
);
1521 atomic_inc(&sbi
->s_curr_pending
);