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/writeback.h>
35 #include <linux/buffer_head.h>
36 #include <scsi/scsi_device.h>
40 #define EXOFS_DBGMSG2(M...) do {} while (0)
42 enum { BIO_MAX_PAGES_KMALLOC
=
43 (PAGE_SIZE
- sizeof(struct bio
)) / sizeof(struct bio_vec
),
45 PAGE_SIZE
/ sizeof(struct page
*),
49 struct exofs_sb_info
*sbi
;
51 unsigned expected_pages
;
52 struct exofs_io_state
*ios
;
58 loff_t pg_first
; /* keep 64bit also in 32-arches */
61 static void _pcol_init(struct page_collect
*pcol
, unsigned expected_pages
,
64 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
68 pcol
->expected_pages
= expected_pages
;
72 pcol
->alloc_pages
= 0;
78 static void _pcol_reset(struct page_collect
*pcol
)
80 pcol
->expected_pages
-= min(pcol
->nr_pages
, pcol
->expected_pages
);
83 pcol
->alloc_pages
= 0;
89 /* this is probably the end of the loop but in writes
90 * it might not end here. don't be left with nothing
92 if (!pcol
->expected_pages
)
93 pcol
->expected_pages
= MAX_PAGES_KMALLOC
;
96 static int pcol_try_alloc(struct page_collect
*pcol
)
98 unsigned pages
= min_t(unsigned, pcol
->expected_pages
,
101 if (!pcol
->ios
) { /* First time allocate io_state */
102 int ret
= exofs_get_io_state(&pcol
->sbi
->layout
, &pcol
->ios
);
108 /* TODO: easily support bio chaining */
109 pages
= min_t(unsigned, pages
,
110 pcol
->sbi
->layout
.group_width
* BIO_MAX_PAGES_KMALLOC
);
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 exofs_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 static int update_read_page(struct page
*page
, int ret
)
151 /* Everything is OK */
152 SetPageUptodate(page
);
154 ClearPageError(page
);
155 } else if (ret
== -EFAULT
) {
156 /* In this case we were trying to read something that wasn't on
157 * disk yet - return a page full of zeroes. This should be OK,
158 * because the object should be empty (if there was a write
159 * before this read, the read would be waiting with the page
161 clear_highpage(page
);
163 SetPageUptodate(page
);
165 ClearPageError(page
);
166 ret
= 0; /* recovered error */
167 EXOFS_DBGMSG("recovered read error\n");
174 static void update_write_page(struct page
*page
, int ret
)
177 mapping_set_error(page
->mapping
, ret
);
180 end_page_writeback(page
);
183 /* Called at the end of reads, to optionally unlock pages and update their
186 static int __readpages_done(struct page_collect
*pcol
, bool do_unlock
)
192 int ret
= exofs_check_io(pcol
->ios
, &resid
);
195 good_bytes
= pcol
->length
;
197 good_bytes
= pcol
->length
- resid
;
199 EXOFS_DBGMSG2("readpages_done(0x%lx) good_bytes=0x%llx"
200 " length=0x%lx nr_pages=%u\n",
201 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
204 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
205 struct page
*page
= pcol
->pages
[i
];
206 struct inode
*inode
= page
->mapping
->host
;
209 if (inode
!= pcol
->inode
)
210 continue; /* osd might add more pages at end */
212 if (likely(length
< good_bytes
))
217 EXOFS_DBGMSG2(" readpages_done(0x%lx, 0x%lx) %s\n",
218 inode
->i_ino
, page
->index
,
219 page_stat
? "bad_bytes" : "good_bytes");
221 ret
= update_read_page(page
, page_stat
);
228 EXOFS_DBGMSG2("readpages_done END\n");
232 /* callback of async reads */
233 static void readpages_done(struct exofs_io_state
*ios
, void *p
)
235 struct page_collect
*pcol
= p
;
237 __readpages_done(pcol
, true);
238 atomic_dec(&pcol
->sbi
->s_curr_pending
);
242 static void _unlock_pcol_pages(struct page_collect
*pcol
, int ret
, int rw
)
246 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
247 struct page
*page
= pcol
->pages
[i
];
250 update_read_page(page
, ret
);
252 update_write_page(page
, ret
);
258 static int read_exec(struct page_collect
*pcol
, bool is_sync
)
260 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
261 struct exofs_io_state
*ios
= pcol
->ios
;
262 struct page_collect
*pcol_copy
= NULL
;
268 /* see comment in _readpage() about sync reads */
269 WARN_ON(is_sync
&& (pcol
->nr_pages
!= 1));
271 ios
->pages
= pcol
->pages
;
272 ios
->nr_pages
= pcol
->nr_pages
;
273 ios
->length
= pcol
->length
;
274 ios
->offset
= pcol
->pg_first
<< PAGE_CACHE_SHIFT
;
277 exofs_oi_read(oi
, pcol
->ios
);
278 return __readpages_done(pcol
, false);
281 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
288 ios
->done
= readpages_done
;
289 ios
->private = pcol_copy
;
290 ret
= exofs_oi_read(oi
, ios
);
294 atomic_inc(&pcol
->sbi
->s_curr_pending
);
296 EXOFS_DBGMSG2("read_exec obj=0x%llx start=0x%llx length=0x%lx\n",
297 ios
->obj
.id
, _LLU(ios
->offset
), pcol
->length
);
299 /* pages ownership was passed to pcol_copy */
305 _unlock_pcol_pages(pcol
, ret
, READ
);
313 /* readpage_strip is called either directly from readpage() or by the VFS from
314 * within read_cache_pages(), to add one more page to be read. It will try to
315 * collect as many contiguous pages as posible. If a discontinuity is
316 * encountered, or it runs out of resources, it will submit the previous segment
317 * and will start a new collection. Eventually caller must submit the last
318 * segment if present.
320 static int readpage_strip(void *data
, struct page
*page
)
322 struct page_collect
*pcol
= data
;
323 struct inode
*inode
= pcol
->inode
;
324 struct exofs_i_info
*oi
= exofs_i(inode
);
325 loff_t i_size
= i_size_read(inode
);
326 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
330 /* FIXME: Just for debugging, will be removed */
331 if (PageUptodate(page
))
332 EXOFS_ERR("PageUptodate(0x%lx, 0x%lx)\n", pcol
->inode
->i_ino
,
335 if (page
->index
< end_index
)
336 len
= PAGE_CACHE_SIZE
;
337 else if (page
->index
== end_index
)
338 len
= i_size
& ~PAGE_CACHE_MASK
;
342 if (!len
|| !obj_created(oi
)) {
343 /* this will be out of bounds, or doesn't exist yet.
344 * Current page is cleared and the request is split
346 clear_highpage(page
);
348 SetPageUptodate(page
);
350 ClearPageError(page
);
353 EXOFS_DBGMSG("readpage_strip(0x%lx, 0x%lx) empty page,"
354 " splitting\n", inode
->i_ino
, page
->index
);
356 return read_exec(pcol
, false);
361 if (unlikely(pcol
->pg_first
== -1)) {
362 pcol
->pg_first
= page
->index
;
363 } else if (unlikely((pcol
->pg_first
+ pcol
->nr_pages
) !=
365 /* Discontinuity detected, split the request */
366 ret
= read_exec(pcol
, false);
373 ret
= pcol_try_alloc(pcol
);
378 if (len
!= PAGE_CACHE_SIZE
)
379 zero_user(page
, len
, PAGE_CACHE_SIZE
- len
);
381 EXOFS_DBGMSG2(" readpage_strip(0x%lx, 0x%lx) len=0x%zx\n",
382 inode
->i_ino
, page
->index
, len
);
384 ret
= pcol_add_page(pcol
, page
, len
);
386 EXOFS_DBGMSG2("Failed pcol_add_page pages[i]=%p "
387 "this_len=0x%zx nr_pages=%u length=0x%lx\n",
388 page
, len
, pcol
->nr_pages
, pcol
->length
);
390 /* split the request, and start again with current page */
391 ret
= read_exec(pcol
, false);
401 /* SetPageError(page); ??? */
406 static int exofs_readpages(struct file
*file
, struct address_space
*mapping
,
407 struct list_head
*pages
, unsigned nr_pages
)
409 struct page_collect pcol
;
412 _pcol_init(&pcol
, nr_pages
, mapping
->host
);
414 ret
= read_cache_pages(mapping
, pages
, readpage_strip
, &pcol
);
416 EXOFS_ERR("read_cache_pages => %d\n", ret
);
420 return read_exec(&pcol
, false);
423 static int _readpage(struct page
*page
, bool is_sync
)
425 struct page_collect pcol
;
428 _pcol_init(&pcol
, 1, page
->mapping
->host
);
430 /* readpage_strip might call read_exec(,is_sync==false) at several
431 * places but not if we have a single page.
433 ret
= readpage_strip(&pcol
, page
);
435 EXOFS_ERR("_readpage => %d\n", ret
);
439 return read_exec(&pcol
, is_sync
);
443 * We don't need the file
445 static int exofs_readpage(struct file
*file
, struct page
*page
)
447 return _readpage(page
, false);
450 /* Callback for osd_write. All writes are asynchronous */
451 static void writepages_done(struct exofs_io_state
*ios
, void *p
)
453 struct page_collect
*pcol
= p
;
458 int ret
= exofs_check_io(ios
, &resid
);
460 atomic_dec(&pcol
->sbi
->s_curr_pending
);
463 good_bytes
= pcol
->length
;
465 good_bytes
= pcol
->length
- resid
;
467 EXOFS_DBGMSG2("writepages_done(0x%lx) good_bytes=0x%llx"
468 " length=0x%lx nr_pages=%u\n",
469 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
472 for (i
= 0; i
< pcol
->nr_pages
; i
++) {
473 struct page
*page
= pcol
->pages
[i
];
474 struct inode
*inode
= page
->mapping
->host
;
477 if (inode
!= pcol
->inode
)
478 continue; /* osd might add more pages to a bio */
480 if (likely(length
< good_bytes
))
485 update_write_page(page
, page_stat
);
487 EXOFS_DBGMSG2(" writepages_done(0x%lx, 0x%lx) status=%d\n",
488 inode
->i_ino
, page
->index
, page_stat
);
495 EXOFS_DBGMSG2("writepages_done END\n");
498 static int write_exec(struct page_collect
*pcol
)
500 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
501 struct exofs_io_state
*ios
= pcol
->ios
;
502 struct page_collect
*pcol_copy
= NULL
;
508 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
510 EXOFS_ERR("write_exec: Faild to kmalloc(pcol)\n");
517 ios
->pages
= pcol_copy
->pages
;
518 ios
->nr_pages
= pcol_copy
->nr_pages
;
519 ios
->offset
= pcol_copy
->pg_first
<< PAGE_CACHE_SHIFT
;
520 ios
->length
= pcol_copy
->length
;
521 ios
->done
= writepages_done
;
522 ios
->private = pcol_copy
;
524 ret
= exofs_oi_write(oi
, ios
);
526 EXOFS_ERR("write_exec: exofs_oi_write() Faild\n");
530 atomic_inc(&pcol
->sbi
->s_curr_pending
);
531 EXOFS_DBGMSG2("write_exec(0x%lx, 0x%llx) start=0x%llx length=0x%lx\n",
532 pcol
->inode
->i_ino
, pcol
->pg_first
, _LLU(ios
->offset
),
534 /* pages ownership was passed to pcol_copy */
539 _unlock_pcol_pages(pcol
, ret
, WRITE
);
546 /* writepage_strip is called either directly from writepage() or by the VFS from
547 * within write_cache_pages(), to add one more page to be written to storage.
548 * It will try to collect as many contiguous pages as possible. If a
549 * discontinuity is encountered or it runs out of resources it will submit the
550 * previous segment and will start a new collection.
551 * Eventually caller must submit the last segment if present.
553 static int writepage_strip(struct page
*page
,
554 struct writeback_control
*wbc_unused
, void *data
)
556 struct page_collect
*pcol
= data
;
557 struct inode
*inode
= pcol
->inode
;
558 struct exofs_i_info
*oi
= exofs_i(inode
);
559 loff_t i_size
= i_size_read(inode
);
560 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
564 BUG_ON(!PageLocked(page
));
566 ret
= wait_obj_created(oi
);
570 if (page
->index
< end_index
)
571 /* in this case, the page is within the limits of the file */
572 len
= PAGE_CACHE_SIZE
;
574 len
= i_size
& ~PAGE_CACHE_MASK
;
576 if (page
->index
> end_index
|| !len
) {
577 /* in this case, the page is outside the limits
578 * (truncate in progress)
580 ret
= write_exec(pcol
);
584 ClearPageError(page
);
586 EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) "
587 "outside the limits\n",
588 inode
->i_ino
, page
->index
);
595 if (unlikely(pcol
->pg_first
== -1)) {
596 pcol
->pg_first
= page
->index
;
597 } else if (unlikely((pcol
->pg_first
+ pcol
->nr_pages
) !=
599 /* Discontinuity detected, split the request */
600 ret
= write_exec(pcol
);
604 EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) Discontinuity\n",
605 inode
->i_ino
, page
->index
);
610 ret
= pcol_try_alloc(pcol
);
615 EXOFS_DBGMSG2(" writepage_strip(0x%lx, 0x%lx) len=0x%zx\n",
616 inode
->i_ino
, page
->index
, len
);
618 ret
= pcol_add_page(pcol
, page
, len
);
620 EXOFS_DBGMSG2("Failed pcol_add_page "
621 "nr_pages=%u total_length=0x%lx\n",
622 pcol
->nr_pages
, pcol
->length
);
624 /* split the request, next loop will start again */
625 ret
= write_exec(pcol
);
627 EXOFS_DBGMSG("write_exec faild => %d", ret
);
634 BUG_ON(PageWriteback(page
));
635 set_page_writeback(page
);
640 EXOFS_DBGMSG("Error: writepage_strip(0x%lx, 0x%lx)=>%d\n",
641 inode
->i_ino
, page
->index
, ret
);
642 set_bit(AS_EIO
, &page
->mapping
->flags
);
647 static int exofs_writepages(struct address_space
*mapping
,
648 struct writeback_control
*wbc
)
650 struct page_collect pcol
;
651 long start
, end
, expected_pages
;
654 start
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
655 end
= (wbc
->range_end
== LLONG_MAX
) ?
656 start
+ mapping
->nrpages
:
657 wbc
->range_end
>> PAGE_CACHE_SHIFT
;
660 expected_pages
= end
- start
+ 1;
662 expected_pages
= mapping
->nrpages
;
664 if (expected_pages
< 32L)
665 expected_pages
= 32L;
667 EXOFS_DBGMSG2("inode(0x%lx) wbc->start=0x%llx wbc->end=0x%llx "
668 "nrpages=%lu start=0x%lx end=0x%lx expected_pages=%ld\n",
669 mapping
->host
->i_ino
, wbc
->range_start
, wbc
->range_end
,
670 mapping
->nrpages
, start
, end
, expected_pages
);
672 _pcol_init(&pcol
, expected_pages
, mapping
->host
);
674 ret
= write_cache_pages(mapping
, wbc
, writepage_strip
, &pcol
);
676 EXOFS_ERR("write_cache_pages => %d\n", ret
);
680 return write_exec(&pcol
);
683 static int exofs_writepage(struct page
*page
, struct writeback_control
*wbc
)
685 struct page_collect pcol
;
688 _pcol_init(&pcol
, 1, page
->mapping
->host
);
690 ret
= writepage_strip(page
, NULL
, &pcol
);
692 EXOFS_ERR("exofs_writepage => %d\n", ret
);
696 return write_exec(&pcol
);
699 int exofs_write_begin(struct file
*file
, struct address_space
*mapping
,
700 loff_t pos
, unsigned len
, unsigned flags
,
701 struct page
**pagep
, void **fsdata
)
708 ret
= simple_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
711 EXOFS_DBGMSG("simple_write_begin faild\n");
718 /* read modify write */
719 if (!PageUptodate(page
) && (len
!= PAGE_CACHE_SIZE
)) {
720 ret
= _readpage(page
, true);
722 /*SetPageError was done by _readpage. Is it ok?*/
724 EXOFS_DBGMSG("__readpage_filler faild\n");
731 static int exofs_write_begin_export(struct file
*file
,
732 struct address_space
*mapping
,
733 loff_t pos
, unsigned len
, unsigned flags
,
734 struct page
**pagep
, void **fsdata
)
738 return exofs_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
742 static int exofs_write_end(struct file
*file
, struct address_space
*mapping
,
743 loff_t pos
, unsigned len
, unsigned copied
,
744 struct page
*page
, void *fsdata
)
746 struct inode
*inode
= mapping
->host
;
747 /* According to comment in simple_write_end i_mutex is held */
748 loff_t i_size
= inode
->i_size
;
751 ret
= simple_write_end(file
, mapping
,pos
, len
, copied
, page
, fsdata
);
752 if (i_size
!= inode
->i_size
)
753 mark_inode_dirty(inode
);
757 const struct address_space_operations exofs_aops
= {
758 .readpage
= exofs_readpage
,
759 .readpages
= exofs_readpages
,
760 .writepage
= exofs_writepage
,
761 .writepages
= exofs_writepages
,
762 .write_begin
= exofs_write_begin_export
,
763 .write_end
= exofs_write_end
,
766 /******************************************************************************
768 *****************************************************************************/
771 * Test whether an inode is a fast symlink.
773 static inline int exofs_inode_is_fast_symlink(struct inode
*inode
)
775 struct exofs_i_info
*oi
= exofs_i(inode
);
777 return S_ISLNK(inode
->i_mode
) && (oi
->i_data
[0] != 0);
781 * get_block_t - Fill in a buffer_head
782 * An OSD takes care of block allocation so we just fake an allocation by
783 * putting in the inode's sector_t in the buffer_head.
784 * TODO: What about the case of create==0 and @iblock does not exist in the
787 static int exofs_get_block(struct inode
*inode
, sector_t iblock
,
788 struct buffer_head
*bh_result
, int create
)
790 map_bh(bh_result
, inode
->i_sb
, iblock
);
794 const struct osd_attr g_attr_logical_length
= ATTR_DEF(
795 OSD_APAGE_OBJECT_INFORMATION
, OSD_ATTR_OI_LOGICAL_LENGTH
, 8);
797 static int _do_truncate(struct inode
*inode
)
799 struct exofs_i_info
*oi
= exofs_i(inode
);
800 loff_t isize
= i_size_read(inode
);
803 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
805 nobh_truncate_page(inode
->i_mapping
, isize
, exofs_get_block
);
807 ret
= exofs_oi_truncate(oi
, (u64
)isize
);
808 EXOFS_DBGMSG("(0x%lx) size=0x%llx\n", inode
->i_ino
, isize
);
813 * Truncate a file to the specified size - all we have to do is set the size
814 * attribute. We make sure the object exists first.
816 void exofs_truncate(struct inode
*inode
)
818 struct exofs_i_info
*oi
= exofs_i(inode
);
821 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
)
822 || S_ISLNK(inode
->i_mode
)))
824 if (exofs_inode_is_fast_symlink(inode
))
826 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
829 /* if we are about to truncate an object, and it hasn't been
832 if (unlikely(wait_obj_created(oi
)))
835 ret
= _do_truncate(inode
);
840 mark_inode_dirty(inode
);
843 make_bad_inode(inode
);
848 * Set inode attributes - just call generic functions.
850 int exofs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
852 struct inode
*inode
= dentry
->d_inode
;
855 error
= inode_change_ok(inode
, iattr
);
859 error
= inode_setattr(inode
, iattr
);
863 static const struct osd_attr g_attr_inode_file_layout
= ATTR_DEF(
865 EXOFS_ATTR_INODE_FILE_LAYOUT
,
867 static const struct osd_attr g_attr_inode_dir_layout
= ATTR_DEF(
869 EXOFS_ATTR_INODE_DIR_LAYOUT
,
873 * Read the Linux inode info from the OSD, and return it as is. In exofs the
874 * inode info is in an application specific page/attribute of the osd-object.
876 static int exofs_get_inode(struct super_block
*sb
, struct exofs_i_info
*oi
,
877 struct exofs_fcb
*inode
)
879 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
880 struct osd_attr attrs
[] = {
881 [0] = g_attr_inode_data
,
882 [1] = g_attr_inode_file_layout
,
883 [2] = g_attr_inode_dir_layout
,
885 struct exofs_io_state
*ios
;
886 struct exofs_on_disk_inode_layout
*layout
;
889 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
891 EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__
);
895 ios
->obj
.id
= exofs_oi_objno(oi
);
896 exofs_make_credential(oi
->i_cred
, &ios
->obj
);
897 ios
->cred
= oi
->i_cred
;
899 attrs
[1].len
= exofs_on_disk_inode_layout_size(sbi
->layout
.s_numdevs
);
900 attrs
[2].len
= exofs_on_disk_inode_layout_size(sbi
->layout
.s_numdevs
);
902 ios
->in_attr
= attrs
;
903 ios
->in_attr_len
= ARRAY_SIZE(attrs
);
905 ret
= exofs_sbi_read(ios
);
907 EXOFS_ERR("object(0x%llx) corrupted, return empty file=>%d\n",
908 _LLU(ios
->obj
.id
), ret
);
909 memset(inode
, 0, sizeof(*inode
));
910 inode
->i_mode
= 0040000 | (0777 & ~022);
911 /* If object is lost on target we might as well enable it's
914 if ((ret
== -ENOENT
) || (ret
== -EINVAL
))
919 ret
= extract_attr_from_ios(ios
, &attrs
[0]);
921 EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__
);
924 WARN_ON(attrs
[0].len
!= EXOFS_INO_ATTR_SIZE
);
925 memcpy(inode
, attrs
[0].val_ptr
, EXOFS_INO_ATTR_SIZE
);
927 ret
= extract_attr_from_ios(ios
, &attrs
[1]);
929 EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__
);
933 layout
= attrs
[1].val_ptr
;
934 if (layout
->gen_func
!= cpu_to_le16(LAYOUT_MOVING_WINDOW
)) {
935 EXOFS_ERR("%s: unsupported files layout %d\n",
936 __func__
, layout
->gen_func
);
942 ret
= extract_attr_from_ios(ios
, &attrs
[2]);
944 EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__
);
948 layout
= attrs
[2].val_ptr
;
949 if (layout
->gen_func
!= cpu_to_le16(LAYOUT_MOVING_WINDOW
)) {
950 EXOFS_ERR("%s: unsupported meta-data layout %d\n",
951 __func__
, layout
->gen_func
);
958 exofs_put_io_state(ios
);
962 static void __oi_init(struct exofs_i_info
*oi
)
964 init_waitqueue_head(&oi
->i_wq
);
968 * Fill in an inode read from the OSD and set it up for use
970 struct inode
*exofs_iget(struct super_block
*sb
, unsigned long ino
)
972 struct exofs_i_info
*oi
;
973 struct exofs_fcb fcb
;
977 inode
= iget_locked(sb
, ino
);
979 return ERR_PTR(-ENOMEM
);
980 if (!(inode
->i_state
& I_NEW
))
985 /* read the inode from the osd */
986 ret
= exofs_get_inode(sb
, oi
, &fcb
);
992 /* copy stuff from on-disk struct to in-memory struct */
993 inode
->i_mode
= le16_to_cpu(fcb
.i_mode
);
994 inode
->i_uid
= le32_to_cpu(fcb
.i_uid
);
995 inode
->i_gid
= le32_to_cpu(fcb
.i_gid
);
996 inode
->i_nlink
= le16_to_cpu(fcb
.i_links_count
);
997 inode
->i_ctime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_ctime
);
998 inode
->i_atime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_atime
);
999 inode
->i_mtime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_mtime
);
1000 inode
->i_ctime
.tv_nsec
=
1001 inode
->i_atime
.tv_nsec
= inode
->i_mtime
.tv_nsec
= 0;
1002 oi
->i_commit_size
= le64_to_cpu(fcb
.i_size
);
1003 i_size_write(inode
, oi
->i_commit_size
);
1004 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
1005 inode
->i_generation
= le32_to_cpu(fcb
.i_generation
);
1007 oi
->i_dir_start_lookup
= 0;
1009 if ((inode
->i_nlink
== 0) && (inode
->i_mode
== 0)) {
1014 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1017 old_decode_dev(le32_to_cpu(fcb
.i_data
[0]));
1020 new_decode_dev(le32_to_cpu(fcb
.i_data
[1]));
1022 memcpy(oi
->i_data
, fcb
.i_data
, sizeof(fcb
.i_data
));
1025 if (S_ISREG(inode
->i_mode
)) {
1026 inode
->i_op
= &exofs_file_inode_operations
;
1027 inode
->i_fop
= &exofs_file_operations
;
1028 inode
->i_mapping
->a_ops
= &exofs_aops
;
1029 } else if (S_ISDIR(inode
->i_mode
)) {
1030 inode
->i_op
= &exofs_dir_inode_operations
;
1031 inode
->i_fop
= &exofs_dir_operations
;
1032 inode
->i_mapping
->a_ops
= &exofs_aops
;
1033 } else if (S_ISLNK(inode
->i_mode
)) {
1034 if (exofs_inode_is_fast_symlink(inode
))
1035 inode
->i_op
= &exofs_fast_symlink_inode_operations
;
1037 inode
->i_op
= &exofs_symlink_inode_operations
;
1038 inode
->i_mapping
->a_ops
= &exofs_aops
;
1041 inode
->i_op
= &exofs_special_inode_operations
;
1043 init_special_inode(inode
, inode
->i_mode
,
1044 old_decode_dev(le32_to_cpu(fcb
.i_data
[0])));
1046 init_special_inode(inode
, inode
->i_mode
,
1047 new_decode_dev(le32_to_cpu(fcb
.i_data
[1])));
1050 unlock_new_inode(inode
);
1055 return ERR_PTR(ret
);
1058 int __exofs_wait_obj_created(struct exofs_i_info
*oi
)
1060 if (!obj_created(oi
)) {
1061 BUG_ON(!obj_2bcreated(oi
));
1062 wait_event(oi
->i_wq
, obj_created(oi
));
1064 return unlikely(is_bad_inode(&oi
->vfs_inode
)) ? -EIO
: 0;
1067 * Callback function from exofs_new_inode(). The important thing is that we
1068 * set the obj_created flag so that other methods know that the object exists on
1071 static void create_done(struct exofs_io_state
*ios
, void *p
)
1073 struct inode
*inode
= p
;
1074 struct exofs_i_info
*oi
= exofs_i(inode
);
1075 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
1078 ret
= exofs_check_io(ios
, NULL
);
1079 exofs_put_io_state(ios
);
1081 atomic_dec(&sbi
->s_curr_pending
);
1083 if (unlikely(ret
)) {
1084 EXOFS_ERR("object=0x%llx creation faild in pid=0x%llx",
1085 _LLU(exofs_oi_objno(oi
)), _LLU(sbi
->layout
.s_pid
));
1086 /*TODO: When FS is corrupted creation can fail, object already
1087 * exist. Get rid of this asynchronous creation, if exist
1088 * increment the obj counter and try the next object. Until we
1089 * succeed. All these dangling objects will be made into lost
1090 * files by chkfs.exofs
1094 set_obj_created(oi
);
1096 atomic_dec(&inode
->i_count
);
1101 * Set up a new inode and create an object for it on the OSD
1103 struct inode
*exofs_new_inode(struct inode
*dir
, int mode
)
1105 struct super_block
*sb
;
1106 struct inode
*inode
;
1107 struct exofs_i_info
*oi
;
1108 struct exofs_sb_info
*sbi
;
1109 struct exofs_io_state
*ios
;
1113 inode
= new_inode(sb
);
1115 return ERR_PTR(-ENOMEM
);
1117 oi
= exofs_i(inode
);
1120 set_obj_2bcreated(oi
);
1122 sbi
= sb
->s_fs_info
;
1125 inode
->i_uid
= current
->cred
->fsuid
;
1126 if (dir
->i_mode
& S_ISGID
) {
1127 inode
->i_gid
= dir
->i_gid
;
1131 inode
->i_gid
= current
->cred
->fsgid
;
1133 inode
->i_mode
= mode
;
1135 inode
->i_ino
= sbi
->s_nextid
++;
1136 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
1137 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
1138 oi
->i_commit_size
= inode
->i_size
= 0;
1139 spin_lock(&sbi
->s_next_gen_lock
);
1140 inode
->i_generation
= sbi
->s_next_generation
++;
1141 spin_unlock(&sbi
->s_next_gen_lock
);
1142 insert_inode_hash(inode
);
1144 mark_inode_dirty(inode
);
1146 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
1147 if (unlikely(ret
)) {
1148 EXOFS_ERR("exofs_new_inode: exofs_get_io_state failed\n");
1149 return ERR_PTR(ret
);
1152 ios
->obj
.id
= exofs_oi_objno(oi
);
1153 exofs_make_credential(oi
->i_cred
, &ios
->obj
);
1155 /* increment the refcount so that the inode will still be around when we
1156 * reach the callback
1158 atomic_inc(&inode
->i_count
);
1160 ios
->done
= create_done
;
1161 ios
->private = inode
;
1162 ios
->cred
= oi
->i_cred
;
1163 ret
= exofs_sbi_create(ios
);
1165 atomic_dec(&inode
->i_count
);
1166 exofs_put_io_state(ios
);
1167 return ERR_PTR(ret
);
1169 atomic_inc(&sbi
->s_curr_pending
);
1175 * struct to pass two arguments to update_inode's callback
1177 struct updatei_args
{
1178 struct exofs_sb_info
*sbi
;
1179 struct exofs_fcb fcb
;
1183 * Callback function from exofs_update_inode().
1185 static void updatei_done(struct exofs_io_state
*ios
, void *p
)
1187 struct updatei_args
*args
= p
;
1189 exofs_put_io_state(ios
);
1191 atomic_dec(&args
->sbi
->s_curr_pending
);
1197 * Write the inode to the OSD. Just fill up the struct, and set the attribute
1198 * synchronously or asynchronously depending on the do_sync flag.
1200 static int exofs_update_inode(struct inode
*inode
, int do_sync
)
1202 struct exofs_i_info
*oi
= exofs_i(inode
);
1203 struct super_block
*sb
= inode
->i_sb
;
1204 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1205 struct exofs_io_state
*ios
;
1206 struct osd_attr attr
;
1207 struct exofs_fcb
*fcb
;
1208 struct updatei_args
*args
;
1211 args
= kzalloc(sizeof(*args
), GFP_KERNEL
);
1213 EXOFS_DBGMSG("Faild kzalloc of args\n");
1219 fcb
->i_mode
= cpu_to_le16(inode
->i_mode
);
1220 fcb
->i_uid
= cpu_to_le32(inode
->i_uid
);
1221 fcb
->i_gid
= cpu_to_le32(inode
->i_gid
);
1222 fcb
->i_links_count
= cpu_to_le16(inode
->i_nlink
);
1223 fcb
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
1224 fcb
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
1225 fcb
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
1226 oi
->i_commit_size
= i_size_read(inode
);
1227 fcb
->i_size
= cpu_to_le64(oi
->i_commit_size
);
1228 fcb
->i_generation
= cpu_to_le32(inode
->i_generation
);
1230 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1231 if (old_valid_dev(inode
->i_rdev
)) {
1233 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
1238 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
1242 memcpy(fcb
->i_data
, oi
->i_data
, sizeof(fcb
->i_data
));
1244 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
1245 if (unlikely(ret
)) {
1246 EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__
);
1250 attr
= g_attr_inode_data
;
1252 ios
->out_attr_len
= 1;
1253 ios
->out_attr
= &attr
;
1255 if (!obj_created(oi
)) {
1256 EXOFS_DBGMSG("!obj_created\n");
1257 BUG_ON(!obj_2bcreated(oi
));
1258 wait_event(oi
->i_wq
, obj_created(oi
));
1259 EXOFS_DBGMSG("wait_event done\n");
1264 ios
->done
= updatei_done
;
1265 ios
->private = args
;
1268 ret
= exofs_oi_write(oi
, ios
);
1269 if (!do_sync
&& !ret
) {
1270 atomic_inc(&sbi
->s_curr_pending
);
1271 goto out
; /* deallocation in updatei_done */
1274 exofs_put_io_state(ios
);
1278 EXOFS_DBGMSG("(0x%lx) do_sync=%d ret=>%d\n",
1279 inode
->i_ino
, do_sync
, ret
);
1283 int exofs_write_inode(struct inode
*inode
, struct writeback_control
*wbc
)
1285 return exofs_update_inode(inode
, wbc
->sync_mode
== WB_SYNC_ALL
);
1289 * Callback function from exofs_delete_inode() - don't have much cleaning up to
1292 static void delete_done(struct exofs_io_state
*ios
, void *p
)
1294 struct exofs_sb_info
*sbi
= p
;
1296 exofs_put_io_state(ios
);
1298 atomic_dec(&sbi
->s_curr_pending
);
1302 * Called when the refcount of an inode reaches zero. We remove the object
1303 * from the OSD here. We make sure the object was created before we try and
1306 void exofs_delete_inode(struct inode
*inode
)
1308 struct exofs_i_info
*oi
= exofs_i(inode
);
1309 struct super_block
*sb
= inode
->i_sb
;
1310 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1311 struct exofs_io_state
*ios
;
1314 truncate_inode_pages(&inode
->i_data
, 0);
1316 if (is_bad_inode(inode
))
1319 mark_inode_dirty(inode
);
1320 exofs_update_inode(inode
, inode_needs_sync(inode
));
1323 if (inode
->i_blocks
)
1324 exofs_truncate(inode
);
1328 ret
= exofs_get_io_state(&sbi
->layout
, &ios
);
1329 if (unlikely(ret
)) {
1330 EXOFS_ERR("%s: exofs_get_io_state failed\n", __func__
);
1334 /* if we are deleting an obj that hasn't been created yet, wait */
1335 if (!obj_created(oi
)) {
1336 BUG_ON(!obj_2bcreated(oi
));
1337 wait_event(oi
->i_wq
, obj_created(oi
));
1340 ios
->obj
.id
= exofs_oi_objno(oi
);
1341 ios
->done
= delete_done
;
1343 ios
->cred
= oi
->i_cred
;
1344 ret
= exofs_sbi_remove(ios
);
1346 EXOFS_ERR("%s: exofs_sbi_remove failed\n", __func__
);
1347 exofs_put_io_state(ios
);
1350 atomic_inc(&sbi
->s_curr_pending
);