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 enum { BIO_MAX_PAGES_KMALLOC
=
41 (PAGE_SIZE
- sizeof(struct bio
)) / sizeof(struct bio_vec
),
43 PAGE_SIZE
/ sizeof(struct page
*),
46 unsigned exofs_max_io_pages(struct exofs_layout
*layout
,
47 unsigned expected_pages
)
49 unsigned pages
= min_t(unsigned, expected_pages
, MAX_PAGES_KMALLOC
);
51 /* TODO: easily support bio chaining */
52 pages
= min_t(unsigned, pages
,
53 layout
->group_width
* BIO_MAX_PAGES_KMALLOC
);
58 struct exofs_sb_info
*sbi
;
60 unsigned expected_pages
;
61 struct exofs_io_state
*ios
;
67 loff_t pg_first
; /* keep 64bit also in 32-arches */
68 bool read_4_write
; /* This means two things: that the read is sync
69 * And the pages should not be unlocked.
73 static void _pcol_init(struct page_collect
*pcol
, unsigned expected_pages
,
76 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
80 pcol
->expected_pages
= expected_pages
;
84 pcol
->alloc_pages
= 0;
88 pcol
->read_4_write
= false;
91 static void _pcol_reset(struct page_collect
*pcol
)
93 pcol
->expected_pages
-= min(pcol
->nr_pages
, pcol
->expected_pages
);
96 pcol
->alloc_pages
= 0;
102 /* this is probably the end of the loop but in writes
103 * it might not end here. don't be left with nothing
105 if (!pcol
->expected_pages
)
106 pcol
->expected_pages
= MAX_PAGES_KMALLOC
;
109 static int pcol_try_alloc(struct page_collect
*pcol
)
113 /* TODO: easily support bio chaining */
114 pages
= exofs_max_io_pages(&pcol
->sbi
->layout
, pcol
->expected_pages
);
116 for (; pages
; pages
>>= 1) {
117 pcol
->pages
= kmalloc(pages
* sizeof(struct page
*),
119 if (likely(pcol
->pages
)) {
120 pcol
->alloc_pages
= pages
;
125 EXOFS_ERR("Failed to kmalloc expected_pages=%u\n",
126 pcol
->expected_pages
);
130 static void pcol_free(struct page_collect
*pcol
)
136 exofs_put_io_state(pcol
->ios
);
141 static int pcol_add_page(struct page_collect
*pcol
, struct page
*page
,
144 if (unlikely(pcol
->nr_pages
>= pcol
->alloc_pages
))
147 pcol
->pages
[pcol
->nr_pages
++] = page
;
152 static int update_read_page(struct page
*page
, int ret
)
155 /* Everything is OK */
156 SetPageUptodate(page
);
158 ClearPageError(page
);
159 } else if (ret
== -EFAULT
) {
160 /* In this case we were trying to read something that wasn't on
161 * disk yet - return a page full of zeroes. This should be OK,
162 * because the object should be empty (if there was a write
163 * before this read, the read would be waiting with the page
165 clear_highpage(page
);
167 SetPageUptodate(page
);
169 ClearPageError(page
);
170 ret
= 0; /* recovered error */
171 EXOFS_DBGMSG("recovered read error\n");
178 static void update_write_page(struct page
*page
, int ret
)
181 mapping_set_error(page
->mapping
, ret
);
184 end_page_writeback(page
);
187 /* Called at the end of reads, to optionally unlock pages and update their
190 static int __readpages_done(struct page_collect
*pcol
)
196 int ret
= exofs_check_io(pcol
->ios
, &resid
);
199 good_bytes
= pcol
->length
;
201 good_bytes
= pcol
->length
- resid
;
203 EXOFS_DBGMSG2("readpages_done(0x%lx) good_bytes=0x%llx"
204 " length=0x%lx nr_pages=%u\n",
205 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
208 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
209 struct page
*page
= pcol
->pages
[i
];
210 struct inode
*inode
= page
->mapping
->host
;
213 if (inode
!= pcol
->inode
)
214 continue; /* osd might add more pages at end */
216 if (likely(length
< good_bytes
))
221 EXOFS_DBGMSG2(" readpages_done(0x%lx, 0x%lx) %s\n",
222 inode
->i_ino
, page
->index
,
223 page_stat
? "bad_bytes" : "good_bytes");
225 ret
= update_read_page(page
, page_stat
);
226 if (!pcol
->read_4_write
)
232 EXOFS_DBGMSG2("readpages_done END\n");
236 /* callback of async reads */
237 static void readpages_done(struct exofs_io_state
*ios
, void *p
)
239 struct page_collect
*pcol
= p
;
241 __readpages_done(pcol
);
242 atomic_dec(&pcol
->sbi
->s_curr_pending
);
246 static void _unlock_pcol_pages(struct page_collect
*pcol
, int ret
, int rw
)
250 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
251 struct page
*page
= pcol
->pages
[i
];
254 update_read_page(page
, ret
);
256 update_write_page(page
, ret
);
262 static int read_exec(struct page_collect
*pcol
)
264 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
265 struct exofs_io_state
*ios
;
266 struct page_collect
*pcol_copy
= NULL
;
273 int ret
= exofs_get_rw_state(&pcol
->sbi
->layout
, true,
274 pcol
->pg_first
<< PAGE_CACHE_SHIFT
,
275 pcol
->length
, &pcol
->ios
);
282 ios
->pages
= pcol
->pages
;
283 ios
->nr_pages
= pcol
->nr_pages
;
285 if (pcol
->read_4_write
) {
286 exofs_oi_read(oi
, pcol
->ios
);
287 return __readpages_done(pcol
);
290 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
297 ios
->done
= readpages_done
;
298 ios
->private = pcol_copy
;
299 ret
= exofs_oi_read(oi
, ios
);
303 atomic_inc(&pcol
->sbi
->s_curr_pending
);
305 EXOFS_DBGMSG2("read_exec obj=0x%llx start=0x%llx length=0x%lx\n",
306 ios
->obj
.id
, _LLU(ios
->offset
), pcol
->length
);
308 /* pages ownership was passed to pcol_copy */
313 if (!pcol
->read_4_write
)
314 _unlock_pcol_pages(pcol
, ret
, READ
);
322 /* readpage_strip is called either directly from readpage() or by the VFS from
323 * within read_cache_pages(), to add one more page to be read. It will try to
324 * collect as many contiguous pages as posible. If a discontinuity is
325 * encountered, or it runs out of resources, it will submit the previous segment
326 * and will start a new collection. Eventually caller must submit the last
327 * segment if present.
329 static int readpage_strip(void *data
, struct page
*page
)
331 struct page_collect
*pcol
= data
;
332 struct inode
*inode
= pcol
->inode
;
333 struct exofs_i_info
*oi
= exofs_i(inode
);
334 loff_t i_size
= i_size_read(inode
);
335 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
339 /* FIXME: Just for debugging, will be removed */
340 if (PageUptodate(page
))
341 EXOFS_ERR("PageUptodate(0x%lx, 0x%lx)\n", pcol
->inode
->i_ino
,
344 if (page
->index
< end_index
)
345 len
= PAGE_CACHE_SIZE
;
346 else if (page
->index
== end_index
)
347 len
= i_size
& ~PAGE_CACHE_MASK
;
351 if (!len
|| !obj_created(oi
)) {
352 /* this will be out of bounds, or doesn't exist yet.
353 * Current page is cleared and the request is split
355 clear_highpage(page
);
357 SetPageUptodate(page
);
359 ClearPageError(page
);
361 if (!pcol
->read_4_write
)
363 EXOFS_DBGMSG("readpage_strip(0x%lx) empty page len=%zx "
364 "read_4_write=%d index=0x%lx end_index=0x%lx "
365 "splitting\n", inode
->i_ino
, len
,
366 pcol
->read_4_write
, page
->index
, end_index
);
368 return read_exec(pcol
);
373 if (unlikely(pcol
->pg_first
== -1)) {
374 pcol
->pg_first
= page
->index
;
375 } else if (unlikely((pcol
->pg_first
+ pcol
->nr_pages
) !=
377 /* Discontinuity detected, split the request */
378 ret
= read_exec(pcol
);
385 ret
= pcol_try_alloc(pcol
);
390 if (len
!= PAGE_CACHE_SIZE
)
391 zero_user(page
, len
, PAGE_CACHE_SIZE
- len
);
393 EXOFS_DBGMSG2(" readpage_strip(0x%lx, 0x%lx) len=0x%zx\n",
394 inode
->i_ino
, page
->index
, len
);
396 ret
= pcol_add_page(pcol
, page
, len
);
398 EXOFS_DBGMSG2("Failed pcol_add_page pages[i]=%p "
399 "this_len=0x%zx nr_pages=%u length=0x%lx\n",
400 page
, len
, pcol
->nr_pages
, pcol
->length
);
402 /* split the request, and start again with current page */
403 ret
= read_exec(pcol
);
413 /* SetPageError(page); ??? */
418 static int exofs_readpages(struct file
*file
, struct address_space
*mapping
,
419 struct list_head
*pages
, unsigned nr_pages
)
421 struct page_collect pcol
;
424 _pcol_init(&pcol
, nr_pages
, mapping
->host
);
426 ret
= read_cache_pages(mapping
, pages
, readpage_strip
, &pcol
);
428 EXOFS_ERR("read_cache_pages => %d\n", ret
);
432 return read_exec(&pcol
);
435 static int _readpage(struct page
*page
, bool read_4_write
)
437 struct page_collect pcol
;
440 _pcol_init(&pcol
, 1, page
->mapping
->host
);
442 pcol
.read_4_write
= read_4_write
;
443 ret
= readpage_strip(&pcol
, page
);
445 EXOFS_ERR("_readpage => %d\n", ret
);
449 return read_exec(&pcol
);
453 * We don't need the file
455 static int exofs_readpage(struct file
*file
, struct page
*page
)
457 return _readpage(page
, false);
460 /* Callback for osd_write. All writes are asynchronous */
461 static void writepages_done(struct exofs_io_state
*ios
, void *p
)
463 struct page_collect
*pcol
= p
;
468 int ret
= exofs_check_io(ios
, &resid
);
470 atomic_dec(&pcol
->sbi
->s_curr_pending
);
473 good_bytes
= pcol
->length
;
475 good_bytes
= pcol
->length
- resid
;
477 EXOFS_DBGMSG2("writepages_done(0x%lx) good_bytes=0x%llx"
478 " length=0x%lx nr_pages=%u\n",
479 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
482 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
483 struct page
*page
= pcol
->pages
[i
];
484 struct inode
*inode
= page
->mapping
->host
;
487 if (inode
!= pcol
->inode
)
488 continue; /* osd might add more pages to a bio */
490 if (likely(length
< good_bytes
))
495 update_write_page(page
, page_stat
);
497 EXOFS_DBGMSG2(" writepages_done(0x%lx, 0x%lx) status=%d\n",
498 inode
->i_ino
, page
->index
, page_stat
);
505 EXOFS_DBGMSG2("writepages_done END\n");
508 static int write_exec(struct page_collect
*pcol
)
510 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
511 struct exofs_io_state
*ios
;
512 struct page_collect
*pcol_copy
= NULL
;
519 ret
= exofs_get_rw_state(&pcol
->sbi
->layout
, false,
520 pcol
->pg_first
<< PAGE_CACHE_SHIFT
,
521 pcol
->length
, &pcol
->ios
);
526 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
528 EXOFS_ERR("write_exec: Failed to kmalloc(pcol)\n");
536 ios
->pages
= pcol_copy
->pages
;
537 ios
->nr_pages
= pcol_copy
->nr_pages
;
538 ios
->done
= writepages_done
;
539 ios
->private = pcol_copy
;
541 ret
= exofs_oi_write(oi
, ios
);
543 EXOFS_ERR("write_exec: exofs_oi_write() Failed\n");
547 atomic_inc(&pcol
->sbi
->s_curr_pending
);
548 EXOFS_DBGMSG2("write_exec(0x%lx, 0x%llx) start=0x%llx length=0x%lx\n",
549 pcol
->inode
->i_ino
, pcol
->pg_first
, _LLU(ios
->offset
),
551 /* pages ownership was passed to pcol_copy */
556 _unlock_pcol_pages(pcol
, ret
, WRITE
);
563 /* writepage_strip is called either directly from writepage() or by the VFS from
564 * within write_cache_pages(), to add one more page to be written to storage.
565 * It will try to collect as many contiguous pages as possible. If a
566 * discontinuity is encountered or it runs out of resources it will submit the
567 * previous segment and will start a new collection.
568 * Eventually caller must submit the last segment if present.
570 static int writepage_strip(struct page
*page
,
571 struct writeback_control
*wbc_unused
, void *data
)
573 struct page_collect
*pcol
= data
;
574 struct inode
*inode
= pcol
->inode
;
575 struct exofs_i_info
*oi
= exofs_i(inode
);
576 loff_t i_size
= i_size_read(inode
);
577 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
581 BUG_ON(!PageLocked(page
));
583 ret
= wait_obj_created(oi
);
587 if (page
->index
< end_index
)
588 /* in this case, the page is within the limits of the file */
589 len
= PAGE_CACHE_SIZE
;
591 len
= i_size
& ~PAGE_CACHE_MASK
;
593 if (page
->index
> end_index
|| !len
) {
594 /* in this case, the page is outside the limits
595 * (truncate in progress)
597 ret
= write_exec(pcol
);
601 ClearPageError(page
);
603 EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) "
604 "outside the limits\n",
605 inode
->i_ino
, page
->index
);
612 if (unlikely(pcol
->pg_first
== -1)) {
613 pcol
->pg_first
= page
->index
;
614 } else if (unlikely((pcol
->pg_first
+ pcol
->nr_pages
) !=
616 /* Discontinuity detected, split the request */
617 ret
= write_exec(pcol
);
621 EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) Discontinuity\n",
622 inode
->i_ino
, page
->index
);
627 ret
= pcol_try_alloc(pcol
);
632 EXOFS_DBGMSG2(" writepage_strip(0x%lx, 0x%lx) len=0x%zx\n",
633 inode
->i_ino
, page
->index
, len
);
635 ret
= pcol_add_page(pcol
, page
, len
);
637 EXOFS_DBGMSG2("Failed pcol_add_page "
638 "nr_pages=%u total_length=0x%lx\n",
639 pcol
->nr_pages
, pcol
->length
);
641 /* split the request, next loop will start again */
642 ret
= write_exec(pcol
);
644 EXOFS_DBGMSG("write_exec failed => %d", ret
);
651 BUG_ON(PageWriteback(page
));
652 set_page_writeback(page
);
657 EXOFS_DBGMSG("Error: writepage_strip(0x%lx, 0x%lx)=>%d\n",
658 inode
->i_ino
, page
->index
, ret
);
659 set_bit(AS_EIO
, &page
->mapping
->flags
);
664 static int exofs_writepages(struct address_space
*mapping
,
665 struct writeback_control
*wbc
)
667 struct page_collect pcol
;
668 long start
, end
, expected_pages
;
671 start
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
672 end
= (wbc
->range_end
== LLONG_MAX
) ?
673 start
+ mapping
->nrpages
:
674 wbc
->range_end
>> PAGE_CACHE_SHIFT
;
677 expected_pages
= end
- start
+ 1;
679 expected_pages
= mapping
->nrpages
;
681 if (expected_pages
< 32L)
682 expected_pages
= 32L;
684 EXOFS_DBGMSG2("inode(0x%lx) wbc->start=0x%llx wbc->end=0x%llx "
685 "nrpages=%lu start=0x%lx end=0x%lx expected_pages=%ld\n",
686 mapping
->host
->i_ino
, wbc
->range_start
, wbc
->range_end
,
687 mapping
->nrpages
, start
, end
, expected_pages
);
689 _pcol_init(&pcol
, expected_pages
, mapping
->host
);
691 ret
= write_cache_pages(mapping
, wbc
, writepage_strip
, &pcol
);
693 EXOFS_ERR("write_cache_pages => %d\n", ret
);
697 return write_exec(&pcol
);
700 static int exofs_writepage(struct page
*page
, struct writeback_control
*wbc
)
702 struct page_collect pcol
;
705 _pcol_init(&pcol
, 1, page
->mapping
->host
);
707 ret
= writepage_strip(page
, NULL
, &pcol
);
709 EXOFS_ERR("exofs_writepage => %d\n", ret
);
713 return write_exec(&pcol
);
716 /* i_mutex held using inode->i_size directly */
717 static void _write_failed(struct inode
*inode
, loff_t to
)
719 if (to
> inode
->i_size
)
720 truncate_pagecache(inode
, to
, inode
->i_size
);
723 int exofs_write_begin(struct file
*file
, struct address_space
*mapping
,
724 loff_t pos
, unsigned len
, unsigned flags
,
725 struct page
**pagep
, void **fsdata
)
732 ret
= simple_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
735 EXOFS_DBGMSG("simple_write_begin failed\n");
742 /* read modify write */
743 if (!PageUptodate(page
) && (len
!= PAGE_CACHE_SIZE
)) {
744 loff_t i_size
= i_size_read(mapping
->host
);
745 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
748 if (page
->index
< end_index
)
749 rlen
= PAGE_CACHE_SIZE
;
750 else if (page
->index
== end_index
)
751 rlen
= i_size
& ~PAGE_CACHE_MASK
;
756 clear_highpage(page
);
757 SetPageUptodate(page
);
761 ret
= _readpage(page
, true);
763 /*SetPageError was done by _readpage. Is it ok?*/
765 EXOFS_DBGMSG("__readpage failed\n");
770 _write_failed(mapping
->host
, pos
+ len
);
775 static int exofs_write_begin_export(struct file
*file
,
776 struct address_space
*mapping
,
777 loff_t pos
, unsigned len
, unsigned flags
,
778 struct page
**pagep
, void **fsdata
)
782 return exofs_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
786 static int exofs_write_end(struct file
*file
, struct address_space
*mapping
,
787 loff_t pos
, unsigned len
, unsigned copied
,
788 struct page
*page
, void *fsdata
)
790 struct inode
*inode
= mapping
->host
;
791 /* According to comment in simple_write_end i_mutex is held */
792 loff_t i_size
= inode
->i_size
;
795 ret
= simple_write_end(file
, mapping
,pos
, len
, copied
, page
, fsdata
);
797 _write_failed(inode
, pos
+ len
);
799 /* TODO: once simple_write_end marks inode dirty remove */
800 if (i_size
!= inode
->i_size
)
801 mark_inode_dirty(inode
);
805 static int exofs_releasepage(struct page
*page
, gfp_t gfp
)
807 EXOFS_DBGMSG("page 0x%lx\n", page
->index
);
812 static void exofs_invalidatepage(struct page
*page
, unsigned long offset
)
814 EXOFS_DBGMSG("page 0x%lx offset 0x%lx\n", page
->index
, offset
);
818 const struct address_space_operations exofs_aops
= {
819 .readpage
= exofs_readpage
,
820 .readpages
= exofs_readpages
,
821 .writepage
= exofs_writepage
,
822 .writepages
= exofs_writepages
,
823 .write_begin
= exofs_write_begin_export
,
824 .write_end
= exofs_write_end
,
825 .releasepage
= exofs_releasepage
,
826 .set_page_dirty
= __set_page_dirty_nobuffers
,
827 .invalidatepage
= exofs_invalidatepage
,
829 /* Not implemented Yet */
830 .bmap
= NULL
, /* TODO: use osd's OSD_ACT_READ_MAP */
831 .direct_IO
= NULL
, /* TODO: Should be trivial to do */
833 /* With these NULL has special meaning or default is not exported */
836 .launder_page
= NULL
,
837 .is_partially_uptodate
= NULL
,
838 .error_remove_page
= NULL
,
841 /******************************************************************************
843 *****************************************************************************/
846 * Test whether an inode is a fast symlink.
848 static inline int exofs_inode_is_fast_symlink(struct inode
*inode
)
850 struct exofs_i_info
*oi
= exofs_i(inode
);
852 return S_ISLNK(inode
->i_mode
) && (oi
->i_data
[0] != 0);
855 const struct osd_attr g_attr_logical_length
= ATTR_DEF(
856 OSD_APAGE_OBJECT_INFORMATION
, OSD_ATTR_OI_LOGICAL_LENGTH
, 8);
858 static int _do_truncate(struct inode
*inode
, loff_t newsize
)
860 struct exofs_i_info
*oi
= exofs_i(inode
);
863 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
865 ret
= exofs_oi_truncate(oi
, (u64
)newsize
);
867 truncate_setsize(inode
, newsize
);
869 EXOFS_DBGMSG("(0x%lx) size=0x%llx ret=>%d\n",
870 inode
->i_ino
, newsize
, ret
);
875 * Set inode attributes - update size attribute on OSD if needed,
876 * otherwise just call generic functions.
878 int exofs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
880 struct inode
*inode
= dentry
->d_inode
;
883 /* if we are about to modify an object, and it hasn't been
886 error
= wait_obj_created(exofs_i(inode
));
890 error
= inode_change_ok(inode
, iattr
);
894 if ((iattr
->ia_valid
& ATTR_SIZE
) &&
895 iattr
->ia_size
!= i_size_read(inode
)) {
896 error
= _do_truncate(inode
, iattr
->ia_size
);
901 setattr_copy(inode
, iattr
);
902 mark_inode_dirty(inode
);
906 static const struct osd_attr g_attr_inode_file_layout
= ATTR_DEF(
908 EXOFS_ATTR_INODE_FILE_LAYOUT
,
910 static const struct osd_attr g_attr_inode_dir_layout
= ATTR_DEF(
912 EXOFS_ATTR_INODE_DIR_LAYOUT
,
916 * Read the Linux inode info from the OSD, and return it as is. In exofs the
917 * inode info is in an application specific page/attribute of the osd-object.
919 static int exofs_get_inode(struct super_block
*sb
, struct exofs_i_info
*oi
,
920 struct exofs_fcb
*inode
)
922 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
923 struct osd_attr attrs
[] = {
924 [0] = g_attr_inode_data
,
925 [1] = g_attr_inode_file_layout
,
926 [2] = g_attr_inode_dir_layout
,
928 struct exofs_io_state
*ios
;
929 struct exofs_on_disk_inode_layout
*layout
;
932 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
934 EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__
);
938 ios
->obj
.id
= exofs_oi_objno(oi
);
939 exofs_make_credential(oi
->i_cred
, &ios
->obj
);
940 ios
->cred
= oi
->i_cred
;
942 attrs
[1].len
= exofs_on_disk_inode_layout_size(sbi
->layout
.s_numdevs
);
943 attrs
[2].len
= exofs_on_disk_inode_layout_size(sbi
->layout
.s_numdevs
);
945 ios
->in_attr
= attrs
;
946 ios
->in_attr_len
= ARRAY_SIZE(attrs
);
948 ret
= exofs_sbi_read(ios
);
950 EXOFS_ERR("object(0x%llx) corrupted, return empty file=>%d\n",
951 _LLU(ios
->obj
.id
), ret
);
952 memset(inode
, 0, sizeof(*inode
));
953 inode
->i_mode
= 0040000 | (0777 & ~022);
954 /* If object is lost on target we might as well enable it's
957 if ((ret
== -ENOENT
) || (ret
== -EINVAL
))
962 ret
= extract_attr_from_ios(ios
, &attrs
[0]);
964 EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__
);
967 WARN_ON(attrs
[0].len
!= EXOFS_INO_ATTR_SIZE
);
968 memcpy(inode
, attrs
[0].val_ptr
, EXOFS_INO_ATTR_SIZE
);
970 ret
= extract_attr_from_ios(ios
, &attrs
[1]);
972 EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__
);
976 layout
= attrs
[1].val_ptr
;
977 if (layout
->gen_func
!= cpu_to_le16(LAYOUT_MOVING_WINDOW
)) {
978 EXOFS_ERR("%s: unsupported files layout %d\n",
979 __func__
, layout
->gen_func
);
985 ret
= extract_attr_from_ios(ios
, &attrs
[2]);
987 EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__
);
991 layout
= attrs
[2].val_ptr
;
992 if (layout
->gen_func
!= cpu_to_le16(LAYOUT_MOVING_WINDOW
)) {
993 EXOFS_ERR("%s: unsupported meta-data layout %d\n",
994 __func__
, layout
->gen_func
);
1001 exofs_put_io_state(ios
);
1005 static void __oi_init(struct exofs_i_info
*oi
)
1007 init_waitqueue_head(&oi
->i_wq
);
1011 * Fill in an inode read from the OSD and set it up for use
1013 struct inode
*exofs_iget(struct super_block
*sb
, unsigned long ino
)
1015 struct exofs_i_info
*oi
;
1016 struct exofs_fcb fcb
;
1017 struct inode
*inode
;
1020 inode
= iget_locked(sb
, ino
);
1022 return ERR_PTR(-ENOMEM
);
1023 if (!(inode
->i_state
& I_NEW
))
1025 oi
= exofs_i(inode
);
1028 /* read the inode from the osd */
1029 ret
= exofs_get_inode(sb
, oi
, &fcb
);
1033 set_obj_created(oi
);
1035 /* copy stuff from on-disk struct to in-memory struct */
1036 inode
->i_mode
= le16_to_cpu(fcb
.i_mode
);
1037 inode
->i_uid
= le32_to_cpu(fcb
.i_uid
);
1038 inode
->i_gid
= le32_to_cpu(fcb
.i_gid
);
1039 inode
->i_nlink
= le16_to_cpu(fcb
.i_links_count
);
1040 inode
->i_ctime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_ctime
);
1041 inode
->i_atime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_atime
);
1042 inode
->i_mtime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_mtime
);
1043 inode
->i_ctime
.tv_nsec
=
1044 inode
->i_atime
.tv_nsec
= inode
->i_mtime
.tv_nsec
= 0;
1045 oi
->i_commit_size
= le64_to_cpu(fcb
.i_size
);
1046 i_size_write(inode
, oi
->i_commit_size
);
1047 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
1048 inode
->i_generation
= le32_to_cpu(fcb
.i_generation
);
1050 oi
->i_dir_start_lookup
= 0;
1052 if ((inode
->i_nlink
== 0) && (inode
->i_mode
== 0)) {
1057 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1060 old_decode_dev(le32_to_cpu(fcb
.i_data
[0]));
1063 new_decode_dev(le32_to_cpu(fcb
.i_data
[1]));
1065 memcpy(oi
->i_data
, fcb
.i_data
, sizeof(fcb
.i_data
));
1068 inode
->i_mapping
->backing_dev_info
= sb
->s_bdi
;
1069 if (S_ISREG(inode
->i_mode
)) {
1070 inode
->i_op
= &exofs_file_inode_operations
;
1071 inode
->i_fop
= &exofs_file_operations
;
1072 inode
->i_mapping
->a_ops
= &exofs_aops
;
1073 } else if (S_ISDIR(inode
->i_mode
)) {
1074 inode
->i_op
= &exofs_dir_inode_operations
;
1075 inode
->i_fop
= &exofs_dir_operations
;
1076 inode
->i_mapping
->a_ops
= &exofs_aops
;
1077 } else if (S_ISLNK(inode
->i_mode
)) {
1078 if (exofs_inode_is_fast_symlink(inode
))
1079 inode
->i_op
= &exofs_fast_symlink_inode_operations
;
1081 inode
->i_op
= &exofs_symlink_inode_operations
;
1082 inode
->i_mapping
->a_ops
= &exofs_aops
;
1085 inode
->i_op
= &exofs_special_inode_operations
;
1087 init_special_inode(inode
, inode
->i_mode
,
1088 old_decode_dev(le32_to_cpu(fcb
.i_data
[0])));
1090 init_special_inode(inode
, inode
->i_mode
,
1091 new_decode_dev(le32_to_cpu(fcb
.i_data
[1])));
1094 unlock_new_inode(inode
);
1099 return ERR_PTR(ret
);
1102 int __exofs_wait_obj_created(struct exofs_i_info
*oi
)
1104 if (!obj_created(oi
)) {
1105 EXOFS_DBGMSG("!obj_created\n");
1106 BUG_ON(!obj_2bcreated(oi
));
1107 wait_event(oi
->i_wq
, obj_created(oi
));
1108 EXOFS_DBGMSG("wait_event done\n");
1110 return unlikely(is_bad_inode(&oi
->vfs_inode
)) ? -EIO
: 0;
1114 * Callback function from exofs_new_inode(). The important thing is that we
1115 * set the obj_created flag so that other methods know that the object exists on
1118 static void create_done(struct exofs_io_state
*ios
, void *p
)
1120 struct inode
*inode
= p
;
1121 struct exofs_i_info
*oi
= exofs_i(inode
);
1122 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
1125 ret
= exofs_check_io(ios
, NULL
);
1126 exofs_put_io_state(ios
);
1128 atomic_dec(&sbi
->s_curr_pending
);
1130 if (unlikely(ret
)) {
1131 EXOFS_ERR("object=0x%llx creation failed in pid=0x%llx",
1132 _LLU(exofs_oi_objno(oi
)), _LLU(sbi
->layout
.s_pid
));
1133 /*TODO: When FS is corrupted creation can fail, object already
1134 * exist. Get rid of this asynchronous creation, if exist
1135 * increment the obj counter and try the next object. Until we
1136 * succeed. All these dangling objects will be made into lost
1137 * files by chkfs.exofs
1141 set_obj_created(oi
);
1147 * Set up a new inode and create an object for it on the OSD
1149 struct inode
*exofs_new_inode(struct inode
*dir
, int mode
)
1151 struct super_block
*sb
;
1152 struct inode
*inode
;
1153 struct exofs_i_info
*oi
;
1154 struct exofs_sb_info
*sbi
;
1155 struct exofs_io_state
*ios
;
1159 inode
= new_inode(sb
);
1161 return ERR_PTR(-ENOMEM
);
1163 oi
= exofs_i(inode
);
1166 set_obj_2bcreated(oi
);
1168 sbi
= sb
->s_fs_info
;
1170 inode
->i_mapping
->backing_dev_info
= sb
->s_bdi
;
1171 inode_init_owner(inode
, dir
, mode
);
1172 inode
->i_ino
= sbi
->s_nextid
++;
1173 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
1174 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
1175 oi
->i_commit_size
= inode
->i_size
= 0;
1176 spin_lock(&sbi
->s_next_gen_lock
);
1177 inode
->i_generation
= sbi
->s_next_generation
++;
1178 spin_unlock(&sbi
->s_next_gen_lock
);
1179 insert_inode_hash(inode
);
1181 exofs_sbi_write_stats(sbi
); /* Make sure new sbi->s_nextid is on disk */
1183 mark_inode_dirty(inode
);
1185 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
1186 if (unlikely(ret
)) {
1187 EXOFS_ERR("exofs_new_inode: exofs_get_io_state failed\n");
1188 return ERR_PTR(ret
);
1191 ios
->obj
.id
= exofs_oi_objno(oi
);
1192 exofs_make_credential(oi
->i_cred
, &ios
->obj
);
1194 ios
->done
= create_done
;
1195 ios
->private = inode
;
1196 ios
->cred
= oi
->i_cred
;
1197 ret
= exofs_sbi_create(ios
);
1199 exofs_put_io_state(ios
);
1200 return ERR_PTR(ret
);
1202 atomic_inc(&sbi
->s_curr_pending
);
1208 * struct to pass two arguments to update_inode's callback
1210 struct updatei_args
{
1211 struct exofs_sb_info
*sbi
;
1212 struct exofs_fcb fcb
;
1216 * Callback function from exofs_update_inode().
1218 static void updatei_done(struct exofs_io_state
*ios
, void *p
)
1220 struct updatei_args
*args
= p
;
1222 exofs_put_io_state(ios
);
1224 atomic_dec(&args
->sbi
->s_curr_pending
);
1230 * Write the inode to the OSD. Just fill up the struct, and set the attribute
1231 * synchronously or asynchronously depending on the do_sync flag.
1233 static int exofs_update_inode(struct inode
*inode
, int do_sync
)
1235 struct exofs_i_info
*oi
= exofs_i(inode
);
1236 struct super_block
*sb
= inode
->i_sb
;
1237 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1238 struct exofs_io_state
*ios
;
1239 struct osd_attr attr
;
1240 struct exofs_fcb
*fcb
;
1241 struct updatei_args
*args
;
1244 args
= kzalloc(sizeof(*args
), GFP_KERNEL
);
1246 EXOFS_DBGMSG("Failed kzalloc of args\n");
1252 fcb
->i_mode
= cpu_to_le16(inode
->i_mode
);
1253 fcb
->i_uid
= cpu_to_le32(inode
->i_uid
);
1254 fcb
->i_gid
= cpu_to_le32(inode
->i_gid
);
1255 fcb
->i_links_count
= cpu_to_le16(inode
->i_nlink
);
1256 fcb
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
1257 fcb
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
1258 fcb
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
1259 oi
->i_commit_size
= i_size_read(inode
);
1260 fcb
->i_size
= cpu_to_le64(oi
->i_commit_size
);
1261 fcb
->i_generation
= cpu_to_le32(inode
->i_generation
);
1263 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1264 if (old_valid_dev(inode
->i_rdev
)) {
1266 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
1271 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
1275 memcpy(fcb
->i_data
, oi
->i_data
, sizeof(fcb
->i_data
));
1277 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
1278 if (unlikely(ret
)) {
1279 EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__
);
1283 attr
= g_attr_inode_data
;
1285 ios
->out_attr_len
= 1;
1286 ios
->out_attr
= &attr
;
1288 wait_obj_created(oi
);
1292 ios
->done
= updatei_done
;
1293 ios
->private = args
;
1296 ret
= exofs_oi_write(oi
, ios
);
1297 if (!do_sync
&& !ret
) {
1298 atomic_inc(&sbi
->s_curr_pending
);
1299 goto out
; /* deallocation in updatei_done */
1302 exofs_put_io_state(ios
);
1306 EXOFS_DBGMSG("(0x%lx) do_sync=%d ret=>%d\n",
1307 inode
->i_ino
, do_sync
, ret
);
1311 int exofs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1313 /* FIXME: fix fsync and use wbc->sync_mode == WB_SYNC_ALL */
1314 return exofs_update_inode(inode
, 1);
1318 * Callback function from exofs_delete_inode() - don't have much cleaning up to
1321 static void delete_done(struct exofs_io_state
*ios
, void *p
)
1323 struct exofs_sb_info
*sbi
= p
;
1325 exofs_put_io_state(ios
);
1327 atomic_dec(&sbi
->s_curr_pending
);
1331 * Called when the refcount of an inode reaches zero. We remove the object
1332 * from the OSD here. We make sure the object was created before we try and
1335 void exofs_evict_inode(struct inode
*inode
)
1337 struct exofs_i_info
*oi
= exofs_i(inode
);
1338 struct super_block
*sb
= inode
->i_sb
;
1339 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1340 struct exofs_io_state
*ios
;
1343 truncate_inode_pages(&inode
->i_data
, 0);
1345 /* TODO: should do better here */
1346 if (inode
->i_nlink
|| is_bad_inode(inode
))
1350 end_writeback(inode
);
1352 /* if we are deleting an obj that hasn't been created yet, wait.
1353 * This also makes sure that create_done cannot be called with an
1354 * already evicted inode.
1356 wait_obj_created(oi
);
1357 /* ignore the error, attempt a remove anyway */
1359 /* Now Remove the OSD objects */
1360 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
1361 if (unlikely(ret
)) {
1362 EXOFS_ERR("%s: exofs_get_io_state failed\n", __func__
);
1366 ios
->obj
.id
= exofs_oi_objno(oi
);
1367 ios
->done
= delete_done
;
1369 ios
->cred
= oi
->i_cred
;
1370 ret
= exofs_sbi_remove(ios
);
1372 EXOFS_ERR("%s: exofs_sbi_remove failed\n", __func__
);
1373 exofs_put_io_state(ios
);
1376 atomic_inc(&sbi
->s_curr_pending
);
1381 end_writeback(inode
);