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 #ifdef CONFIG_EXOFS_DEBUG
41 # define EXOFS_DEBUG_OBJ_ISIZE 1
45 struct exofs_sb_info
*sbi
;
46 struct request_queue
*req_q
;
48 unsigned expected_pages
;
53 loff_t pg_first
; /* keep 64bit also in 32-arches */
56 static void _pcol_init(struct page_collect
*pcol
, unsigned expected_pages
,
59 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
62 pcol
->req_q
= osd_request_queue(sbi
->s_dev
);
64 pcol
->expected_pages
= expected_pages
;
71 EXOFS_DBGMSG("_pcol_init ino=0x%lx expected_pages=%u\n", inode
->i_ino
,
75 static void _pcol_reset(struct page_collect
*pcol
)
77 pcol
->expected_pages
-= min(pcol
->nr_pages
, pcol
->expected_pages
);
83 EXOFS_DBGMSG("_pcol_reset ino=0x%lx expected_pages=%u\n",
84 pcol
->inode
->i_ino
, pcol
->expected_pages
);
86 /* this is probably the end of the loop but in writes
87 * it might not end here. don't be left with nothing
89 if (!pcol
->expected_pages
)
90 pcol
->expected_pages
= 128;
93 static int pcol_try_alloc(struct page_collect
*pcol
)
95 int pages
= min_t(unsigned, pcol
->expected_pages
, BIO_MAX_PAGES
);
97 for (; pages
; pages
>>= 1) {
98 pcol
->bio
= bio_alloc(GFP_KERNEL
, pages
);
99 if (likely(pcol
->bio
))
103 EXOFS_ERR("Failed to kcalloc expected_pages=%u\n",
104 pcol
->expected_pages
);
108 static void pcol_free(struct page_collect
*pcol
)
114 static int pcol_add_page(struct page_collect
*pcol
, struct page
*page
,
117 int added_len
= bio_add_pc_page(pcol
->req_q
, pcol
->bio
, page
, len
, 0);
118 if (unlikely(len
!= added_len
))
126 static int update_read_page(struct page
*page
, int ret
)
129 /* Everything is OK */
130 SetPageUptodate(page
);
132 ClearPageError(page
);
133 } else if (ret
== -EFAULT
) {
134 /* In this case we were trying to read something that wasn't on
135 * disk yet - return a page full of zeroes. This should be OK,
136 * because the object should be empty (if there was a write
137 * before this read, the read would be waiting with the page
139 clear_highpage(page
);
141 SetPageUptodate(page
);
143 ClearPageError(page
);
144 ret
= 0; /* recovered error */
145 EXOFS_DBGMSG("recovered read error\n");
152 static void update_write_page(struct page
*page
, int ret
)
155 mapping_set_error(page
->mapping
, ret
);
158 end_page_writeback(page
);
161 /* Called at the end of reads, to optionally unlock pages and update their
164 static int __readpages_done(struct osd_request
*or, struct page_collect
*pcol
,
167 struct bio_vec
*bvec
;
172 int ret
= exofs_check_ok_resid(or, &resid
, NULL
);
177 good_bytes
= pcol
->length
;
181 good_bytes
= pcol
->length
- resid
;
183 EXOFS_DBGMSG("readpages_done(0x%lx) good_bytes=0x%llx"
184 " length=0x%lx nr_pages=%u\n",
185 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
188 __bio_for_each_segment(bvec
, pcol
->bio
, i
, 0) {
189 struct page
*page
= bvec
->bv_page
;
190 struct inode
*inode
= page
->mapping
->host
;
193 if (inode
!= pcol
->inode
)
194 continue; /* osd might add more pages at end */
196 if (likely(length
< good_bytes
))
201 EXOFS_DBGMSG(" readpages_done(0x%lx, 0x%lx) %s\n",
202 inode
->i_ino
, page
->index
,
203 page_stat
? "bad_bytes" : "good_bytes");
205 ret
= update_read_page(page
, page_stat
);
208 length
+= bvec
->bv_len
;
212 EXOFS_DBGMSG("readpages_done END\n");
216 /* callback of async reads */
217 static void readpages_done(struct osd_request
*or, void *p
)
219 struct page_collect
*pcol
= p
;
221 __readpages_done(or, pcol
, true);
222 atomic_dec(&pcol
->sbi
->s_curr_pending
);
226 static void _unlock_pcol_pages(struct page_collect
*pcol
, int ret
, int rw
)
228 struct bio_vec
*bvec
;
231 __bio_for_each_segment(bvec
, pcol
->bio
, i
, 0) {
232 struct page
*page
= bvec
->bv_page
;
235 update_read_page(page
, ret
);
237 update_write_page(page
, ret
);
244 static int read_exec(struct page_collect
*pcol
, bool is_sync
)
246 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
247 struct osd_obj_id obj
= {pcol
->sbi
->s_pid
,
248 pcol
->inode
->i_ino
+ EXOFS_OBJ_OFF
};
249 struct osd_request
*or = NULL
;
250 struct page_collect
*pcol_copy
= NULL
;
251 loff_t i_start
= pcol
->pg_first
<< PAGE_CACHE_SHIFT
;
257 /* see comment in _readpage() about sync reads */
258 WARN_ON(is_sync
&& (pcol
->nr_pages
!= 1));
260 or = osd_start_request(pcol
->sbi
->s_dev
, GFP_KERNEL
);
266 osd_req_read(or, &obj
, i_start
, pcol
->bio
, pcol
->length
);
269 exofs_sync_op(or, pcol
->sbi
->s_timeout
, oi
->i_cred
);
270 return __readpages_done(or, pcol
, false);
273 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
280 ret
= exofs_async_op(or, readpages_done
, pcol_copy
, oi
->i_cred
);
284 atomic_inc(&pcol
->sbi
->s_curr_pending
);
286 EXOFS_DBGMSG("read_exec obj=0x%llx start=0x%llx length=0x%lx\n",
287 obj
.id
, _LLU(i_start
), pcol
->length
);
289 /* pages ownership was passed to pcol_copy */
295 _unlock_pcol_pages(pcol
, ret
, READ
);
296 else /* Pages unlocked by caller in sync mode only free bio */
305 /* readpage_strip is called either directly from readpage() or by the VFS from
306 * within read_cache_pages(), to add one more page to be read. It will try to
307 * collect as many contiguous pages as posible. If a discontinuity is
308 * encountered, or it runs out of resources, it will submit the previous segment
309 * and will start a new collection. Eventually caller must submit the last
310 * segment if present.
312 static int readpage_strip(void *data
, struct page
*page
)
314 struct page_collect
*pcol
= data
;
315 struct inode
*inode
= pcol
->inode
;
316 struct exofs_i_info
*oi
= exofs_i(inode
);
317 loff_t i_size
= i_size_read(inode
);
318 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
322 /* FIXME: Just for debugging, will be removed */
323 if (PageUptodate(page
))
324 EXOFS_ERR("PageUptodate(0x%lx, 0x%lx)\n", pcol
->inode
->i_ino
,
327 if (page
->index
< end_index
)
328 len
= PAGE_CACHE_SIZE
;
329 else if (page
->index
== end_index
)
330 len
= i_size
& ~PAGE_CACHE_MASK
;
334 if (!len
|| !obj_created(oi
)) {
335 /* this will be out of bounds, or doesn't exist yet.
336 * Current page is cleared and the request is split
338 clear_highpage(page
);
340 SetPageUptodate(page
);
342 ClearPageError(page
);
345 EXOFS_DBGMSG("readpage_strip(0x%lx, 0x%lx) empty page,"
346 " splitting\n", inode
->i_ino
, page
->index
);
348 return read_exec(pcol
, false);
353 if (unlikely(pcol
->pg_first
== -1)) {
354 pcol
->pg_first
= page
->index
;
355 } else if (unlikely((pcol
->pg_first
+ pcol
->nr_pages
) !=
357 /* Discontinuity detected, split the request */
358 ret
= read_exec(pcol
, false);
365 ret
= pcol_try_alloc(pcol
);
370 if (len
!= PAGE_CACHE_SIZE
)
371 zero_user(page
, len
, PAGE_CACHE_SIZE
- len
);
373 EXOFS_DBGMSG(" readpage_strip(0x%lx, 0x%lx) len=0x%zx\n",
374 inode
->i_ino
, page
->index
, len
);
376 ret
= pcol_add_page(pcol
, page
, len
);
378 EXOFS_DBGMSG("Failed pcol_add_page pages[i]=%p "
379 "this_len=0x%zx nr_pages=%u length=0x%lx\n",
380 page
, len
, pcol
->nr_pages
, pcol
->length
);
382 /* split the request, and start again with current page */
383 ret
= read_exec(pcol
, false);
393 /* SetPageError(page); ??? */
398 static int exofs_readpages(struct file
*file
, struct address_space
*mapping
,
399 struct list_head
*pages
, unsigned nr_pages
)
401 struct page_collect pcol
;
404 _pcol_init(&pcol
, nr_pages
, mapping
->host
);
406 ret
= read_cache_pages(mapping
, pages
, readpage_strip
, &pcol
);
408 EXOFS_ERR("read_cache_pages => %d\n", ret
);
412 return read_exec(&pcol
, false);
415 static int _readpage(struct page
*page
, bool is_sync
)
417 struct page_collect pcol
;
420 _pcol_init(&pcol
, 1, page
->mapping
->host
);
422 /* readpage_strip might call read_exec(,async) inside at several places
423 * but this is safe for is_async=0 since read_exec will not do anything
424 * when we have a single page.
426 ret
= readpage_strip(&pcol
, page
);
428 EXOFS_ERR("_readpage => %d\n", ret
);
432 return read_exec(&pcol
, is_sync
);
436 * We don't need the file
438 static int exofs_readpage(struct file
*file
, struct page
*page
)
440 return _readpage(page
, false);
443 /* Callback for osd_write. All writes are asynchronouse */
444 static void writepages_done(struct osd_request
*or, void *p
)
446 struct page_collect
*pcol
= p
;
447 struct bio_vec
*bvec
;
453 int ret
= exofs_check_ok_resid(or, NULL
, &resid
);
456 atomic_dec(&pcol
->sbi
->s_curr_pending
);
459 good_bytes
= pcol
->length
;
463 good_bytes
= pcol
->length
- resid
;
465 EXOFS_DBGMSG("writepages_done(0x%lx) good_bytes=0x%llx"
466 " length=0x%lx nr_pages=%u\n",
467 pcol
->inode
->i_ino
, _LLU(good_bytes
), pcol
->length
,
470 __bio_for_each_segment(bvec
, pcol
->bio
, i
, 0) {
471 struct page
*page
= bvec
->bv_page
;
472 struct inode
*inode
= page
->mapping
->host
;
475 if (inode
!= pcol
->inode
)
476 continue; /* osd might add more pages to a bio */
478 if (likely(length
< good_bytes
))
483 update_write_page(page
, page_stat
);
485 EXOFS_DBGMSG(" writepages_done(0x%lx, 0x%lx) status=%d\n",
486 inode
->i_ino
, page
->index
, page_stat
);
488 length
+= bvec
->bv_len
;
493 EXOFS_DBGMSG("writepages_done END\n");
496 static int write_exec(struct page_collect
*pcol
)
498 struct exofs_i_info
*oi
= exofs_i(pcol
->inode
);
499 struct osd_obj_id obj
= {pcol
->sbi
->s_pid
,
500 pcol
->inode
->i_ino
+ EXOFS_OBJ_OFF
};
501 struct osd_request
*or = NULL
;
502 struct page_collect
*pcol_copy
= NULL
;
503 loff_t i_start
= pcol
->pg_first
<< PAGE_CACHE_SHIFT
;
509 or = osd_start_request(pcol
->sbi
->s_dev
, GFP_KERNEL
);
511 EXOFS_ERR("write_exec: Faild to osd_start_request()\n");
516 pcol_copy
= kmalloc(sizeof(*pcol_copy
), GFP_KERNEL
);
518 EXOFS_ERR("write_exec: Faild to kmalloc(pcol)\n");
525 pcol_copy
->bio
->bi_rw
|= (1 << BIO_RW
); /* FIXME: bio_set_dir() */
526 osd_req_write(or, &obj
, i_start
, pcol_copy
->bio
, pcol_copy
->length
);
527 ret
= exofs_async_op(or, writepages_done
, pcol_copy
, oi
->i_cred
);
529 EXOFS_ERR("write_exec: exofs_async_op() Faild\n");
533 atomic_inc(&pcol
->sbi
->s_curr_pending
);
534 EXOFS_DBGMSG("write_exec(0x%lx, 0x%llx) start=0x%llx length=0x%lx\n",
535 pcol
->inode
->i_ino
, pcol
->pg_first
, _LLU(i_start
),
537 /* pages ownership was passed to pcol_copy */
542 _unlock_pcol_pages(pcol
, ret
, WRITE
);
549 /* writepage_strip is called either directly from writepage() or by the VFS from
550 * within write_cache_pages(), to add one more page to be written to storage.
551 * It will try to collect as many contiguous pages as possible. If a
552 * discontinuity is encountered or it runs out of resources it will submit the
553 * previous segment and will start a new collection.
554 * Eventually caller must submit the last segment if present.
556 static int writepage_strip(struct page
*page
,
557 struct writeback_control
*wbc_unused
, void *data
)
559 struct page_collect
*pcol
= data
;
560 struct inode
*inode
= pcol
->inode
;
561 struct exofs_i_info
*oi
= exofs_i(inode
);
562 loff_t i_size
= i_size_read(inode
);
563 pgoff_t end_index
= i_size
>> PAGE_CACHE_SHIFT
;
567 BUG_ON(!PageLocked(page
));
569 ret
= wait_obj_created(oi
);
573 if (page
->index
< end_index
)
574 /* in this case, the page is within the limits of the file */
575 len
= PAGE_CACHE_SIZE
;
577 len
= i_size
& ~PAGE_CACHE_MASK
;
579 if (page
->index
> end_index
|| !len
) {
580 /* in this case, the page is outside the limits
581 * (truncate in progress)
583 ret
= write_exec(pcol
);
587 ClearPageError(page
);
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
);
607 ret
= pcol_try_alloc(pcol
);
612 EXOFS_DBGMSG(" writepage_strip(0x%lx, 0x%lx) len=0x%zx\n",
613 inode
->i_ino
, page
->index
, len
);
615 ret
= pcol_add_page(pcol
, page
, len
);
617 EXOFS_DBGMSG("Failed pcol_add_page "
618 "nr_pages=%u total_length=0x%lx\n",
619 pcol
->nr_pages
, pcol
->length
);
621 /* split the request, next loop will start again */
622 ret
= write_exec(pcol
);
624 EXOFS_DBGMSG("write_exec faild => %d", ret
);
631 BUG_ON(PageWriteback(page
));
632 set_page_writeback(page
);
637 set_bit(AS_EIO
, &page
->mapping
->flags
);
642 static int exofs_writepages(struct address_space
*mapping
,
643 struct writeback_control
*wbc
)
645 struct page_collect pcol
;
646 long start
, end
, expected_pages
;
649 start
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
650 end
= (wbc
->range_end
== LLONG_MAX
) ?
651 start
+ mapping
->nrpages
:
652 wbc
->range_end
>> PAGE_CACHE_SHIFT
;
655 expected_pages
= min(end
- start
+ 1, 32L);
657 expected_pages
= mapping
->nrpages
;
659 EXOFS_DBGMSG("inode(0x%lx) wbc->start=0x%llx wbc->end=0x%llx"
660 " m->nrpages=%lu start=0x%lx end=0x%lx\n",
661 mapping
->host
->i_ino
, wbc
->range_start
, wbc
->range_end
,
662 mapping
->nrpages
, start
, end
);
664 _pcol_init(&pcol
, expected_pages
, mapping
->host
);
666 ret
= write_cache_pages(mapping
, wbc
, writepage_strip
, &pcol
);
668 EXOFS_ERR("write_cache_pages => %d\n", ret
);
672 return write_exec(&pcol
);
675 static int exofs_writepage(struct page
*page
, struct writeback_control
*wbc
)
677 struct page_collect pcol
;
680 _pcol_init(&pcol
, 1, page
->mapping
->host
);
682 ret
= writepage_strip(page
, NULL
, &pcol
);
684 EXOFS_ERR("exofs_writepage => %d\n", ret
);
688 return write_exec(&pcol
);
691 int exofs_write_begin(struct file
*file
, struct address_space
*mapping
,
692 loff_t pos
, unsigned len
, unsigned flags
,
693 struct page
**pagep
, void **fsdata
)
700 ret
= simple_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
703 EXOFS_DBGMSG("simple_write_begin faild\n");
710 /* read modify write */
711 if (!PageUptodate(page
) && (len
!= PAGE_CACHE_SIZE
)) {
712 ret
= _readpage(page
, true);
714 /*SetPageError was done by _readpage. Is it ok?*/
716 EXOFS_DBGMSG("__readpage_filler faild\n");
723 static int exofs_write_begin_export(struct file
*file
,
724 struct address_space
*mapping
,
725 loff_t pos
, unsigned len
, unsigned flags
,
726 struct page
**pagep
, void **fsdata
)
730 return exofs_write_begin(file
, mapping
, pos
, len
, flags
, pagep
,
734 const struct address_space_operations exofs_aops
= {
735 .readpage
= exofs_readpage
,
736 .readpages
= exofs_readpages
,
737 .writepage
= exofs_writepage
,
738 .writepages
= exofs_writepages
,
739 .write_begin
= exofs_write_begin_export
,
740 .write_end
= simple_write_end
,
743 /******************************************************************************
745 *****************************************************************************/
748 * Test whether an inode is a fast symlink.
750 static inline int exofs_inode_is_fast_symlink(struct inode
*inode
)
752 struct exofs_i_info
*oi
= exofs_i(inode
);
754 return S_ISLNK(inode
->i_mode
) && (oi
->i_data
[0] != 0);
758 * get_block_t - Fill in a buffer_head
759 * An OSD takes care of block allocation so we just fake an allocation by
760 * putting in the inode's sector_t in the buffer_head.
761 * TODO: What about the case of create==0 and @iblock does not exist in the
764 static int exofs_get_block(struct inode
*inode
, sector_t iblock
,
765 struct buffer_head
*bh_result
, int create
)
767 map_bh(bh_result
, inode
->i_sb
, iblock
);
771 const struct osd_attr g_attr_logical_length
= ATTR_DEF(
772 OSD_APAGE_OBJECT_INFORMATION
, OSD_ATTR_OI_LOGICAL_LENGTH
, 8);
775 * Truncate a file to the specified size - all we have to do is set the size
776 * attribute. We make sure the object exists first.
778 void exofs_truncate(struct inode
*inode
)
780 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
781 struct exofs_i_info
*oi
= exofs_i(inode
);
782 struct osd_obj_id obj
= {sbi
->s_pid
, inode
->i_ino
+ EXOFS_OBJ_OFF
};
783 struct osd_request
*or;
784 struct osd_attr attr
;
785 loff_t isize
= i_size_read(inode
);
789 if (!(S_ISREG(inode
->i_mode
) || S_ISDIR(inode
->i_mode
)
790 || S_ISLNK(inode
->i_mode
)))
792 if (exofs_inode_is_fast_symlink(inode
))
794 if (IS_APPEND(inode
) || IS_IMMUTABLE(inode
))
796 inode
->i_mtime
= inode
->i_ctime
= CURRENT_TIME
;
798 nobh_truncate_page(inode
->i_mapping
, isize
, exofs_get_block
);
800 or = osd_start_request(sbi
->s_dev
, GFP_KERNEL
);
802 EXOFS_ERR("ERROR: exofs_truncate: osd_start_request failed\n");
806 osd_req_set_attributes(or, &obj
);
808 newsize
= cpu_to_be64((u64
)isize
);
809 attr
= g_attr_logical_length
;
810 attr
.val_ptr
= &newsize
;
811 osd_req_add_set_attr_list(or, &attr
, 1);
813 /* if we are about to truncate an object, and it hasn't been
816 if (unlikely(wait_obj_created(oi
)))
819 ret
= exofs_sync_op(or, sbi
->s_timeout
, oi
->i_cred
);
825 mark_inode_dirty(inode
);
828 make_bad_inode(inode
);
833 * Set inode attributes - just call generic functions.
835 int exofs_setattr(struct dentry
*dentry
, struct iattr
*iattr
)
837 struct inode
*inode
= dentry
->d_inode
;
840 error
= inode_change_ok(inode
, iattr
);
844 error
= inode_setattr(inode
, iattr
);
849 * Read an inode from the OSD, and return it as is. We also return the size
850 * attribute in the 'sanity' argument if we got compiled with debugging turned
853 static int exofs_get_inode(struct super_block
*sb
, struct exofs_i_info
*oi
,
854 struct exofs_fcb
*inode
, uint64_t *sanity
)
856 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
857 struct osd_request
*or;
858 struct osd_attr attr
;
859 struct osd_obj_id obj
= {sbi
->s_pid
,
860 oi
->vfs_inode
.i_ino
+ EXOFS_OBJ_OFF
};
863 exofs_make_credential(oi
->i_cred
, &obj
);
865 or = osd_start_request(sbi
->s_dev
, GFP_KERNEL
);
867 EXOFS_ERR("exofs_get_inode: osd_start_request failed.\n");
870 osd_req_get_attributes(or, &obj
);
872 /* we need the inode attribute */
873 osd_req_add_get_attr_list(or, &g_attr_inode_data
, 1);
875 #ifdef EXOFS_DEBUG_OBJ_ISIZE
876 /* we get the size attributes to do a sanity check */
877 osd_req_add_get_attr_list(or, &g_attr_logical_length
, 1);
880 ret
= exofs_sync_op(or, sbi
->s_timeout
, oi
->i_cred
);
884 attr
= g_attr_inode_data
;
885 ret
= extract_attr_from_req(or, &attr
);
887 EXOFS_ERR("exofs_get_inode: extract_attr_from_req failed\n");
891 WARN_ON(attr
.len
!= EXOFS_INO_ATTR_SIZE
);
892 memcpy(inode
, attr
.val_ptr
, EXOFS_INO_ATTR_SIZE
);
894 #ifdef EXOFS_DEBUG_OBJ_ISIZE
895 attr
= g_attr_logical_length
;
896 ret
= extract_attr_from_req(or, &attr
);
898 EXOFS_ERR("ERROR: extract attr from or failed\n");
901 *sanity
= get_unaligned_be64(attr
.val_ptr
);
910 static void __oi_init(struct exofs_i_info
*oi
)
912 init_waitqueue_head(&oi
->i_wq
);
916 * Fill in an inode read from the OSD and set it up for use
918 struct inode
*exofs_iget(struct super_block
*sb
, unsigned long ino
)
920 struct exofs_i_info
*oi
;
921 struct exofs_fcb fcb
;
923 uint64_t uninitialized_var(sanity
);
926 inode
= iget_locked(sb
, ino
);
928 return ERR_PTR(-ENOMEM
);
929 if (!(inode
->i_state
& I_NEW
))
934 /* read the inode from the osd */
935 ret
= exofs_get_inode(sb
, oi
, &fcb
, &sanity
);
941 /* copy stuff from on-disk struct to in-memory struct */
942 inode
->i_mode
= le16_to_cpu(fcb
.i_mode
);
943 inode
->i_uid
= le32_to_cpu(fcb
.i_uid
);
944 inode
->i_gid
= le32_to_cpu(fcb
.i_gid
);
945 inode
->i_nlink
= le16_to_cpu(fcb
.i_links_count
);
946 inode
->i_ctime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_ctime
);
947 inode
->i_atime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_atime
);
948 inode
->i_mtime
.tv_sec
= (signed)le32_to_cpu(fcb
.i_mtime
);
949 inode
->i_ctime
.tv_nsec
=
950 inode
->i_atime
.tv_nsec
= inode
->i_mtime
.tv_nsec
= 0;
951 oi
->i_commit_size
= le64_to_cpu(fcb
.i_size
);
952 i_size_write(inode
, oi
->i_commit_size
);
953 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
954 inode
->i_generation
= le32_to_cpu(fcb
.i_generation
);
956 #ifdef EXOFS_DEBUG_OBJ_ISIZE
957 if ((inode
->i_size
!= sanity
) &&
958 (!exofs_inode_is_fast_symlink(inode
))) {
959 EXOFS_ERR("WARNING: Size of inode=%llu != object=%llu\n",
960 inode
->i_size
, _LLU(sanity
));
964 oi
->i_dir_start_lookup
= 0;
966 if ((inode
->i_nlink
== 0) && (inode
->i_mode
== 0)) {
971 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
974 old_decode_dev(le32_to_cpu(fcb
.i_data
[0]));
977 new_decode_dev(le32_to_cpu(fcb
.i_data
[1]));
979 memcpy(oi
->i_data
, fcb
.i_data
, sizeof(fcb
.i_data
));
982 if (S_ISREG(inode
->i_mode
)) {
983 inode
->i_op
= &exofs_file_inode_operations
;
984 inode
->i_fop
= &exofs_file_operations
;
985 inode
->i_mapping
->a_ops
= &exofs_aops
;
986 } else if (S_ISDIR(inode
->i_mode
)) {
987 inode
->i_op
= &exofs_dir_inode_operations
;
988 inode
->i_fop
= &exofs_dir_operations
;
989 inode
->i_mapping
->a_ops
= &exofs_aops
;
990 } else if (S_ISLNK(inode
->i_mode
)) {
991 if (exofs_inode_is_fast_symlink(inode
))
992 inode
->i_op
= &exofs_fast_symlink_inode_operations
;
994 inode
->i_op
= &exofs_symlink_inode_operations
;
995 inode
->i_mapping
->a_ops
= &exofs_aops
;
998 inode
->i_op
= &exofs_special_inode_operations
;
1000 init_special_inode(inode
, inode
->i_mode
,
1001 old_decode_dev(le32_to_cpu(fcb
.i_data
[0])));
1003 init_special_inode(inode
, inode
->i_mode
,
1004 new_decode_dev(le32_to_cpu(fcb
.i_data
[1])));
1007 unlock_new_inode(inode
);
1012 return ERR_PTR(ret
);
1015 int __exofs_wait_obj_created(struct exofs_i_info
*oi
)
1017 if (!obj_created(oi
)) {
1018 BUG_ON(!obj_2bcreated(oi
));
1019 wait_event(oi
->i_wq
, obj_created(oi
));
1021 return unlikely(is_bad_inode(&oi
->vfs_inode
)) ? -EIO
: 0;
1024 * Callback function from exofs_new_inode(). The important thing is that we
1025 * set the obj_created flag so that other methods know that the object exists on
1028 static void create_done(struct osd_request
*or, void *p
)
1030 struct inode
*inode
= p
;
1031 struct exofs_i_info
*oi
= exofs_i(inode
);
1032 struct exofs_sb_info
*sbi
= inode
->i_sb
->s_fs_info
;
1035 ret
= exofs_check_ok(or);
1036 osd_end_request(or);
1037 atomic_dec(&sbi
->s_curr_pending
);
1039 if (unlikely(ret
)) {
1040 EXOFS_ERR("object=0x%llx creation faild in pid=0x%llx",
1041 _LLU(sbi
->s_pid
), _LLU(inode
->i_ino
+ EXOFS_OBJ_OFF
));
1042 make_bad_inode(inode
);
1044 set_obj_created(oi
);
1046 atomic_dec(&inode
->i_count
);
1051 * Set up a new inode and create an object for it on the OSD
1053 struct inode
*exofs_new_inode(struct inode
*dir
, int mode
)
1055 struct super_block
*sb
;
1056 struct inode
*inode
;
1057 struct exofs_i_info
*oi
;
1058 struct exofs_sb_info
*sbi
;
1059 struct osd_request
*or;
1060 struct osd_obj_id obj
;
1064 inode
= new_inode(sb
);
1066 return ERR_PTR(-ENOMEM
);
1068 oi
= exofs_i(inode
);
1071 set_obj_2bcreated(oi
);
1073 sbi
= sb
->s_fs_info
;
1076 inode
->i_uid
= current
->cred
->fsuid
;
1077 if (dir
->i_mode
& S_ISGID
) {
1078 inode
->i_gid
= dir
->i_gid
;
1082 inode
->i_gid
= current
->cred
->fsgid
;
1084 inode
->i_mode
= mode
;
1086 inode
->i_ino
= sbi
->s_nextid
++;
1087 inode
->i_blkbits
= EXOFS_BLKSHIFT
;
1088 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
1089 oi
->i_commit_size
= inode
->i_size
= 0;
1090 spin_lock(&sbi
->s_next_gen_lock
);
1091 inode
->i_generation
= sbi
->s_next_generation
++;
1092 spin_unlock(&sbi
->s_next_gen_lock
);
1093 insert_inode_hash(inode
);
1095 mark_inode_dirty(inode
);
1097 obj
.partition
= sbi
->s_pid
;
1098 obj
.id
= inode
->i_ino
+ EXOFS_OBJ_OFF
;
1099 exofs_make_credential(oi
->i_cred
, &obj
);
1101 or = osd_start_request(sbi
->s_dev
, GFP_KERNEL
);
1102 if (unlikely(!or)) {
1103 EXOFS_ERR("exofs_new_inode: osd_start_request failed\n");
1104 return ERR_PTR(-ENOMEM
);
1107 osd_req_create_object(or, &obj
);
1109 /* increment the refcount so that the inode will still be around when we
1110 * reach the callback
1112 atomic_inc(&inode
->i_count
);
1114 ret
= exofs_async_op(or, create_done
, inode
, oi
->i_cred
);
1116 atomic_dec(&inode
->i_count
);
1117 osd_end_request(or);
1118 return ERR_PTR(-EIO
);
1120 atomic_inc(&sbi
->s_curr_pending
);
1126 * struct to pass two arguments to update_inode's callback
1128 struct updatei_args
{
1129 struct exofs_sb_info
*sbi
;
1130 struct exofs_fcb fcb
;
1134 * Callback function from exofs_update_inode().
1136 static void updatei_done(struct osd_request
*or, void *p
)
1138 struct updatei_args
*args
= p
;
1140 osd_end_request(or);
1142 atomic_dec(&args
->sbi
->s_curr_pending
);
1148 * Write the inode to the OSD. Just fill up the struct, and set the attribute
1149 * synchronously or asynchronously depending on the do_sync flag.
1151 static int exofs_update_inode(struct inode
*inode
, int do_sync
)
1153 struct exofs_i_info
*oi
= exofs_i(inode
);
1154 struct super_block
*sb
= inode
->i_sb
;
1155 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1156 struct osd_obj_id obj
= {sbi
->s_pid
, inode
->i_ino
+ EXOFS_OBJ_OFF
};
1157 struct osd_request
*or;
1158 struct osd_attr attr
;
1159 struct exofs_fcb
*fcb
;
1160 struct updatei_args
*args
;
1163 args
= kzalloc(sizeof(*args
), GFP_KERNEL
);
1169 fcb
->i_mode
= cpu_to_le16(inode
->i_mode
);
1170 fcb
->i_uid
= cpu_to_le32(inode
->i_uid
);
1171 fcb
->i_gid
= cpu_to_le32(inode
->i_gid
);
1172 fcb
->i_links_count
= cpu_to_le16(inode
->i_nlink
);
1173 fcb
->i_ctime
= cpu_to_le32(inode
->i_ctime
.tv_sec
);
1174 fcb
->i_atime
= cpu_to_le32(inode
->i_atime
.tv_sec
);
1175 fcb
->i_mtime
= cpu_to_le32(inode
->i_mtime
.tv_sec
);
1176 oi
->i_commit_size
= i_size_read(inode
);
1177 fcb
->i_size
= cpu_to_le64(oi
->i_commit_size
);
1178 fcb
->i_generation
= cpu_to_le32(inode
->i_generation
);
1180 if (S_ISCHR(inode
->i_mode
) || S_ISBLK(inode
->i_mode
)) {
1181 if (old_valid_dev(inode
->i_rdev
)) {
1183 cpu_to_le32(old_encode_dev(inode
->i_rdev
));
1188 cpu_to_le32(new_encode_dev(inode
->i_rdev
));
1192 memcpy(fcb
->i_data
, oi
->i_data
, sizeof(fcb
->i_data
));
1194 or = osd_start_request(sbi
->s_dev
, GFP_KERNEL
);
1195 if (unlikely(!or)) {
1196 EXOFS_ERR("exofs_update_inode: osd_start_request failed.\n");
1201 osd_req_set_attributes(or, &obj
);
1203 attr
= g_attr_inode_data
;
1205 osd_req_add_set_attr_list(or, &attr
, 1);
1207 if (!obj_created(oi
)) {
1208 EXOFS_DBGMSG("!obj_created\n");
1209 BUG_ON(!obj_2bcreated(oi
));
1210 wait_event(oi
->i_wq
, obj_created(oi
));
1211 EXOFS_DBGMSG("wait_event done\n");
1215 ret
= exofs_sync_op(or, sbi
->s_timeout
, oi
->i_cred
);
1216 osd_end_request(or);
1221 ret
= exofs_async_op(or, updatei_done
, args
, oi
->i_cred
);
1223 osd_end_request(or);
1226 atomic_inc(&sbi
->s_curr_pending
);
1227 goto out
; /* deallocation in updatei_done */
1233 EXOFS_DBGMSG("ret=>%d\n", ret
);
1237 int exofs_write_inode(struct inode
*inode
, int wait
)
1239 return exofs_update_inode(inode
, wait
);
1243 * Callback function from exofs_delete_inode() - don't have much cleaning up to
1246 static void delete_done(struct osd_request
*or, void *p
)
1248 struct exofs_sb_info
*sbi
;
1249 osd_end_request(or);
1251 atomic_dec(&sbi
->s_curr_pending
);
1255 * Called when the refcount of an inode reaches zero. We remove the object
1256 * from the OSD here. We make sure the object was created before we try and
1259 void exofs_delete_inode(struct inode
*inode
)
1261 struct exofs_i_info
*oi
= exofs_i(inode
);
1262 struct super_block
*sb
= inode
->i_sb
;
1263 struct exofs_sb_info
*sbi
= sb
->s_fs_info
;
1264 struct osd_obj_id obj
= {sbi
->s_pid
, inode
->i_ino
+ EXOFS_OBJ_OFF
};
1265 struct osd_request
*or;
1268 truncate_inode_pages(&inode
->i_data
, 0);
1270 if (is_bad_inode(inode
))
1273 mark_inode_dirty(inode
);
1274 exofs_update_inode(inode
, inode_needs_sync(inode
));
1277 if (inode
->i_blocks
)
1278 exofs_truncate(inode
);
1282 or = osd_start_request(sbi
->s_dev
, GFP_KERNEL
);
1283 if (unlikely(!or)) {
1284 EXOFS_ERR("exofs_delete_inode: osd_start_request failed\n");
1288 osd_req_remove_object(or, &obj
);
1290 /* if we are deleting an obj that hasn't been created yet, wait */
1291 if (!obj_created(oi
)) {
1292 BUG_ON(!obj_2bcreated(oi
));
1293 wait_event(oi
->i_wq
, obj_created(oi
));
1296 ret
= exofs_async_op(or, delete_done
, sbi
, oi
->i_cred
);
1299 "ERROR: @exofs_delete_inode exofs_async_op failed\n");
1300 osd_end_request(or);
1303 atomic_inc(&sbi
->s_curr_pending
);