Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005, 2006 |
Boaz Harrosh | 27d2e14 | 2009-06-14 17:23:09 +0300 | [diff] [blame] | 3 | * Avishay Traeger (avishay@gmail.com) |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 4 | * Copyright (C) 2008, 2009 |
| 5 | * Boaz Harrosh <bharrosh@panasas.com> |
| 6 | * |
| 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) |
| 12 | * from |
| 13 | * linux/fs/minix/inode.c |
| 14 | * Copyright (C) 1991, 1992 Linus Torvalds |
| 15 | * |
| 16 | * This file is part of exofs. |
| 17 | * |
| 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. |
| 23 | * |
| 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. |
| 28 | * |
| 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 |
| 32 | */ |
| 33 | |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 34 | #include <linux/slab.h> |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 35 | |
| 36 | #include "exofs.h" |
| 37 | |
Boaz Harrosh | fe33cc1 | 2009-11-01 18:28:14 +0200 | [diff] [blame] | 38 | #define EXOFS_DBGMSG2(M...) do {} while (0) |
| 39 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 40 | enum { BIO_MAX_PAGES_KMALLOC = |
| 41 | (PAGE_SIZE - sizeof(struct bio)) / sizeof(struct bio_vec), |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 42 | MAX_PAGES_KMALLOC = |
| 43 | PAGE_SIZE / sizeof(struct page *), |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 44 | }; |
| 45 | |
bharrosh@panasas.com | 66cd6ca | 2010-10-07 14:28:18 -0400 | [diff] [blame] | 46 | unsigned exofs_max_io_pages(struct exofs_layout *layout, |
| 47 | unsigned expected_pages) |
| 48 | { |
| 49 | unsigned pages = min_t(unsigned, expected_pages, MAX_PAGES_KMALLOC); |
| 50 | |
| 51 | /* TODO: easily support bio chaining */ |
| 52 | pages = min_t(unsigned, pages, |
| 53 | layout->group_width * BIO_MAX_PAGES_KMALLOC); |
| 54 | return pages; |
| 55 | } |
| 56 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 57 | struct page_collect { |
| 58 | struct exofs_sb_info *sbi; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 59 | struct inode *inode; |
| 60 | unsigned expected_pages; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 61 | struct exofs_io_state *ios; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 62 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 63 | struct page **pages; |
| 64 | unsigned alloc_pages; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 65 | unsigned nr_pages; |
| 66 | unsigned long length; |
| 67 | loff_t pg_first; /* keep 64bit also in 32-arches */ |
Boaz Harrosh | f17b1f9 | 2010-10-07 13:37:51 -0400 | [diff] [blame] | 68 | bool read_4_write; /* This means two things: that the read is sync |
| 69 | * And the pages should not be unlocked. |
| 70 | */ |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 71 | }; |
| 72 | |
| 73 | static void _pcol_init(struct page_collect *pcol, unsigned expected_pages, |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 74 | struct inode *inode) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 75 | { |
| 76 | struct exofs_sb_info *sbi = inode->i_sb->s_fs_info; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 77 | |
| 78 | pcol->sbi = sbi; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 79 | pcol->inode = inode; |
| 80 | pcol->expected_pages = expected_pages; |
| 81 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 82 | pcol->ios = NULL; |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 83 | pcol->pages = NULL; |
| 84 | pcol->alloc_pages = 0; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 85 | pcol->nr_pages = 0; |
| 86 | pcol->length = 0; |
| 87 | pcol->pg_first = -1; |
Boaz Harrosh | f17b1f9 | 2010-10-07 13:37:51 -0400 | [diff] [blame] | 88 | pcol->read_4_write = false; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | static void _pcol_reset(struct page_collect *pcol) |
| 92 | { |
| 93 | pcol->expected_pages -= min(pcol->nr_pages, pcol->expected_pages); |
| 94 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 95 | pcol->pages = NULL; |
| 96 | pcol->alloc_pages = 0; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 97 | pcol->nr_pages = 0; |
| 98 | pcol->length = 0; |
| 99 | pcol->pg_first = -1; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 100 | pcol->ios = NULL; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 101 | |
| 102 | /* this is probably the end of the loop but in writes |
| 103 | * it might not end here. don't be left with nothing |
| 104 | */ |
| 105 | if (!pcol->expected_pages) |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 106 | pcol->expected_pages = MAX_PAGES_KMALLOC; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | static int pcol_try_alloc(struct page_collect *pcol) |
| 110 | { |
bharrosh@panasas.com | 66cd6ca | 2010-10-07 14:28:18 -0400 | [diff] [blame] | 111 | unsigned pages; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 112 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 113 | /* TODO: easily support bio chaining */ |
bharrosh@panasas.com | 66cd6ca | 2010-10-07 14:28:18 -0400 | [diff] [blame] | 114 | pages = exofs_max_io_pages(&pcol->sbi->layout, pcol->expected_pages); |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 115 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 116 | for (; pages; pages >>= 1) { |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 117 | pcol->pages = kmalloc(pages * sizeof(struct page *), |
| 118 | GFP_KERNEL); |
| 119 | if (likely(pcol->pages)) { |
| 120 | pcol->alloc_pages = pages; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 121 | return 0; |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 122 | } |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 123 | } |
| 124 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 125 | EXOFS_ERR("Failed to kmalloc expected_pages=%u\n", |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 126 | pcol->expected_pages); |
| 127 | return -ENOMEM; |
| 128 | } |
| 129 | |
| 130 | static void pcol_free(struct page_collect *pcol) |
| 131 | { |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 132 | kfree(pcol->pages); |
| 133 | pcol->pages = NULL; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 134 | |
| 135 | if (pcol->ios) { |
| 136 | exofs_put_io_state(pcol->ios); |
| 137 | pcol->ios = NULL; |
| 138 | } |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 139 | } |
| 140 | |
| 141 | static int pcol_add_page(struct page_collect *pcol, struct page *page, |
| 142 | unsigned len) |
| 143 | { |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 144 | if (unlikely(pcol->nr_pages >= pcol->alloc_pages)) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 145 | return -ENOMEM; |
| 146 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 147 | pcol->pages[pcol->nr_pages++] = page; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 148 | pcol->length += len; |
| 149 | return 0; |
| 150 | } |
| 151 | |
| 152 | static int update_read_page(struct page *page, int ret) |
| 153 | { |
| 154 | if (ret == 0) { |
| 155 | /* Everything is OK */ |
| 156 | SetPageUptodate(page); |
| 157 | if (PageError(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 |
| 164 | * locked */ |
| 165 | clear_highpage(page); |
| 166 | |
| 167 | SetPageUptodate(page); |
| 168 | if (PageError(page)) |
| 169 | ClearPageError(page); |
| 170 | ret = 0; /* recovered error */ |
| 171 | EXOFS_DBGMSG("recovered read error\n"); |
| 172 | } else /* Error */ |
| 173 | SetPageError(page); |
| 174 | |
| 175 | return ret; |
| 176 | } |
| 177 | |
| 178 | static void update_write_page(struct page *page, int ret) |
| 179 | { |
| 180 | if (ret) { |
| 181 | mapping_set_error(page->mapping, ret); |
| 182 | SetPageError(page); |
| 183 | } |
| 184 | end_page_writeback(page); |
| 185 | } |
| 186 | |
| 187 | /* Called at the end of reads, to optionally unlock pages and update their |
| 188 | * status. |
| 189 | */ |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 190 | static int __readpages_done(struct page_collect *pcol) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 191 | { |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 192 | int i; |
| 193 | u64 resid; |
| 194 | u64 good_bytes; |
| 195 | u64 length = 0; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 196 | int ret = exofs_check_io(pcol->ios, &resid); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 197 | |
| 198 | if (likely(!ret)) |
| 199 | good_bytes = pcol->length; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 200 | else |
| 201 | good_bytes = pcol->length - resid; |
| 202 | |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 203 | EXOFS_DBGMSG2("readpages_done(0x%lx) good_bytes=0x%llx" |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 204 | " length=0x%lx nr_pages=%u\n", |
| 205 | pcol->inode->i_ino, _LLU(good_bytes), pcol->length, |
| 206 | pcol->nr_pages); |
| 207 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 208 | for (i = 0; i < pcol->nr_pages; i++) { |
| 209 | struct page *page = pcol->pages[i]; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 210 | struct inode *inode = page->mapping->host; |
| 211 | int page_stat; |
| 212 | |
| 213 | if (inode != pcol->inode) |
| 214 | continue; /* osd might add more pages at end */ |
| 215 | |
| 216 | if (likely(length < good_bytes)) |
| 217 | page_stat = 0; |
| 218 | else |
| 219 | page_stat = ret; |
| 220 | |
Boaz Harrosh | fe33cc1 | 2009-11-01 18:28:14 +0200 | [diff] [blame] | 221 | EXOFS_DBGMSG2(" readpages_done(0x%lx, 0x%lx) %s\n", |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 222 | inode->i_ino, page->index, |
| 223 | page_stat ? "bad_bytes" : "good_bytes"); |
| 224 | |
| 225 | ret = update_read_page(page, page_stat); |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 226 | if (!pcol->read_4_write) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 227 | unlock_page(page); |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 228 | length += PAGE_SIZE; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 229 | } |
| 230 | |
| 231 | pcol_free(pcol); |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 232 | EXOFS_DBGMSG2("readpages_done END\n"); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 233 | return ret; |
| 234 | } |
| 235 | |
| 236 | /* callback of async reads */ |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 237 | static void readpages_done(struct exofs_io_state *ios, void *p) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 238 | { |
| 239 | struct page_collect *pcol = p; |
| 240 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 241 | __readpages_done(pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 242 | atomic_dec(&pcol->sbi->s_curr_pending); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 243 | kfree(pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | static void _unlock_pcol_pages(struct page_collect *pcol, int ret, int rw) |
| 247 | { |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 248 | int i; |
| 249 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 250 | for (i = 0; i < pcol->nr_pages; i++) { |
| 251 | struct page *page = pcol->pages[i]; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 252 | |
| 253 | if (rw == READ) |
| 254 | update_read_page(page, ret); |
| 255 | else |
| 256 | update_write_page(page, ret); |
| 257 | |
| 258 | unlock_page(page); |
| 259 | } |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 260 | } |
| 261 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 262 | static int read_exec(struct page_collect *pcol) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 263 | { |
| 264 | struct exofs_i_info *oi = exofs_i(pcol->inode); |
Boaz Harrosh | e1042ba | 2010-11-16 20:09:58 +0200 | [diff] [blame] | 265 | struct exofs_io_state *ios; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 266 | struct page_collect *pcol_copy = NULL; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 267 | int ret; |
| 268 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 269 | if (!pcol->pages) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 270 | return 0; |
| 271 | |
Boaz Harrosh | e1042ba | 2010-11-16 20:09:58 +0200 | [diff] [blame] | 272 | if (!pcol->ios) { |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 273 | int ret = exofs_get_rw_state(&pcol->sbi->layout, &oi->comps, true, |
Boaz Harrosh | e1042ba | 2010-11-16 20:09:58 +0200 | [diff] [blame] | 274 | pcol->pg_first << PAGE_CACHE_SHIFT, |
| 275 | pcol->length, &pcol->ios); |
| 276 | |
| 277 | if (ret) |
| 278 | return ret; |
| 279 | } |
| 280 | |
| 281 | ios = pcol->ios; |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 282 | ios->pages = pcol->pages; |
| 283 | ios->nr_pages = pcol->nr_pages; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 284 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 285 | if (pcol->read_4_write) { |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 286 | exofs_sbi_read(pcol->ios); |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 287 | return __readpages_done(pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 288 | } |
| 289 | |
| 290 | pcol_copy = kmalloc(sizeof(*pcol_copy), GFP_KERNEL); |
| 291 | if (!pcol_copy) { |
| 292 | ret = -ENOMEM; |
| 293 | goto err; |
| 294 | } |
| 295 | |
| 296 | *pcol_copy = *pcol; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 297 | ios->done = readpages_done; |
| 298 | ios->private = pcol_copy; |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 299 | ret = exofs_sbi_read(ios); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 300 | if (unlikely(ret)) |
| 301 | goto err; |
| 302 | |
| 303 | atomic_inc(&pcol->sbi->s_curr_pending); |
| 304 | |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 305 | EXOFS_DBGMSG2("read_exec obj=0x%llx start=0x%llx length=0x%lx\n", |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 306 | oi->one_comp.obj.id, _LLU(ios->offset), pcol->length); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 307 | |
| 308 | /* pages ownership was passed to pcol_copy */ |
| 309 | _pcol_reset(pcol); |
| 310 | return 0; |
| 311 | |
| 312 | err: |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 313 | if (!pcol->read_4_write) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 314 | _unlock_pcol_pages(pcol, ret, READ); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 315 | |
| 316 | pcol_free(pcol); |
Boaz Harrosh | b76a3f9 | 2009-06-08 19:28:41 +0300 | [diff] [blame] | 317 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 318 | kfree(pcol_copy); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 319 | return ret; |
| 320 | } |
| 321 | |
| 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. |
| 328 | */ |
| 329 | static int readpage_strip(void *data, struct page *page) |
| 330 | { |
| 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; |
| 336 | size_t len; |
| 337 | int ret; |
| 338 | |
| 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, |
| 342 | page->index); |
| 343 | |
| 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; |
| 348 | else |
| 349 | len = 0; |
| 350 | |
| 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 |
| 354 | */ |
| 355 | clear_highpage(page); |
| 356 | |
| 357 | SetPageUptodate(page); |
| 358 | if (PageError(page)) |
| 359 | ClearPageError(page); |
| 360 | |
Boaz Harrosh | f17b1f9 | 2010-10-07 13:37:51 -0400 | [diff] [blame] | 361 | if (!pcol->read_4_write) |
| 362 | unlock_page(page); |
Boaz Harrosh | a8f1418 | 2010-11-22 18:02:45 +0200 | [diff] [blame] | 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); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 367 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 368 | return read_exec(pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 369 | } |
| 370 | |
| 371 | try_again: |
| 372 | |
| 373 | if (unlikely(pcol->pg_first == -1)) { |
| 374 | pcol->pg_first = page->index; |
| 375 | } else if (unlikely((pcol->pg_first + pcol->nr_pages) != |
| 376 | page->index)) { |
| 377 | /* Discontinuity detected, split the request */ |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 378 | ret = read_exec(pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 379 | if (unlikely(ret)) |
| 380 | goto fail; |
| 381 | goto try_again; |
| 382 | } |
| 383 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 384 | if (!pcol->pages) { |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 385 | ret = pcol_try_alloc(pcol); |
| 386 | if (unlikely(ret)) |
| 387 | goto fail; |
| 388 | } |
| 389 | |
| 390 | if (len != PAGE_CACHE_SIZE) |
| 391 | zero_user(page, len, PAGE_CACHE_SIZE - len); |
| 392 | |
Boaz Harrosh | fe33cc1 | 2009-11-01 18:28:14 +0200 | [diff] [blame] | 393 | EXOFS_DBGMSG2(" readpage_strip(0x%lx, 0x%lx) len=0x%zx\n", |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 394 | inode->i_ino, page->index, len); |
| 395 | |
| 396 | ret = pcol_add_page(pcol, page, len); |
| 397 | if (ret) { |
Boaz Harrosh | fe33cc1 | 2009-11-01 18:28:14 +0200 | [diff] [blame] | 398 | EXOFS_DBGMSG2("Failed pcol_add_page pages[i]=%p " |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 399 | "this_len=0x%zx nr_pages=%u length=0x%lx\n", |
| 400 | page, len, pcol->nr_pages, pcol->length); |
| 401 | |
| 402 | /* split the request, and start again with current page */ |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 403 | ret = read_exec(pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 404 | if (unlikely(ret)) |
| 405 | goto fail; |
| 406 | |
| 407 | goto try_again; |
| 408 | } |
| 409 | |
| 410 | return 0; |
| 411 | |
| 412 | fail: |
| 413 | /* SetPageError(page); ??? */ |
| 414 | unlock_page(page); |
| 415 | return ret; |
| 416 | } |
| 417 | |
| 418 | static int exofs_readpages(struct file *file, struct address_space *mapping, |
| 419 | struct list_head *pages, unsigned nr_pages) |
| 420 | { |
| 421 | struct page_collect pcol; |
| 422 | int ret; |
| 423 | |
| 424 | _pcol_init(&pcol, nr_pages, mapping->host); |
| 425 | |
| 426 | ret = read_cache_pages(mapping, pages, readpage_strip, &pcol); |
| 427 | if (ret) { |
| 428 | EXOFS_ERR("read_cache_pages => %d\n", ret); |
| 429 | return ret; |
| 430 | } |
| 431 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 432 | return read_exec(&pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 433 | } |
| 434 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 435 | static int _readpage(struct page *page, bool read_4_write) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 436 | { |
| 437 | struct page_collect pcol; |
| 438 | int ret; |
| 439 | |
| 440 | _pcol_init(&pcol, 1, page->mapping->host); |
| 441 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 442 | pcol.read_4_write = read_4_write; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 443 | ret = readpage_strip(&pcol, page); |
| 444 | if (ret) { |
| 445 | EXOFS_ERR("_readpage => %d\n", ret); |
| 446 | return ret; |
| 447 | } |
| 448 | |
Boaz Harrosh | 7aebf41 | 2010-10-13 12:55:43 -0400 | [diff] [blame] | 449 | return read_exec(&pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 450 | } |
| 451 | |
| 452 | /* |
| 453 | * We don't need the file |
| 454 | */ |
| 455 | static int exofs_readpage(struct file *file, struct page *page) |
| 456 | { |
| 457 | return _readpage(page, false); |
| 458 | } |
| 459 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 460 | /* Callback for osd_write. All writes are asynchronous */ |
| 461 | static void writepages_done(struct exofs_io_state *ios, void *p) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 462 | { |
| 463 | struct page_collect *pcol = p; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 464 | int i; |
| 465 | u64 resid; |
| 466 | u64 good_bytes; |
| 467 | u64 length = 0; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 468 | int ret = exofs_check_io(ios, &resid); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 469 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 470 | atomic_dec(&pcol->sbi->s_curr_pending); |
| 471 | |
| 472 | if (likely(!ret)) |
| 473 | good_bytes = pcol->length; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 474 | else |
| 475 | good_bytes = pcol->length - resid; |
| 476 | |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 477 | EXOFS_DBGMSG2("writepages_done(0x%lx) good_bytes=0x%llx" |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 478 | " length=0x%lx nr_pages=%u\n", |
| 479 | pcol->inode->i_ino, _LLU(good_bytes), pcol->length, |
| 480 | pcol->nr_pages); |
| 481 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 482 | for (i = 0; i < pcol->nr_pages; i++) { |
| 483 | struct page *page = pcol->pages[i]; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 484 | struct inode *inode = page->mapping->host; |
| 485 | int page_stat; |
| 486 | |
| 487 | if (inode != pcol->inode) |
| 488 | continue; /* osd might add more pages to a bio */ |
| 489 | |
| 490 | if (likely(length < good_bytes)) |
| 491 | page_stat = 0; |
| 492 | else |
| 493 | page_stat = ret; |
| 494 | |
| 495 | update_write_page(page, page_stat); |
| 496 | unlock_page(page); |
Boaz Harrosh | fe33cc1 | 2009-11-01 18:28:14 +0200 | [diff] [blame] | 497 | EXOFS_DBGMSG2(" writepages_done(0x%lx, 0x%lx) status=%d\n", |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 498 | inode->i_ino, page->index, page_stat); |
| 499 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 500 | length += PAGE_SIZE; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 501 | } |
| 502 | |
| 503 | pcol_free(pcol); |
| 504 | kfree(pcol); |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 505 | EXOFS_DBGMSG2("writepages_done END\n"); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 506 | } |
| 507 | |
| 508 | static int write_exec(struct page_collect *pcol) |
| 509 | { |
| 510 | struct exofs_i_info *oi = exofs_i(pcol->inode); |
Boaz Harrosh | e1042ba | 2010-11-16 20:09:58 +0200 | [diff] [blame] | 511 | struct exofs_io_state *ios; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 512 | struct page_collect *pcol_copy = NULL; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 513 | int ret; |
| 514 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 515 | if (!pcol->pages) |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 516 | return 0; |
| 517 | |
Boaz Harrosh | e1042ba | 2010-11-16 20:09:58 +0200 | [diff] [blame] | 518 | BUG_ON(pcol->ios); |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 519 | ret = exofs_get_rw_state(&pcol->sbi->layout, &oi->comps, false, |
Boaz Harrosh | e1042ba | 2010-11-16 20:09:58 +0200 | [diff] [blame] | 520 | pcol->pg_first << PAGE_CACHE_SHIFT, |
| 521 | pcol->length, &pcol->ios); |
| 522 | |
| 523 | if (unlikely(ret)) |
| 524 | goto err; |
| 525 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 526 | pcol_copy = kmalloc(sizeof(*pcol_copy), GFP_KERNEL); |
| 527 | if (!pcol_copy) { |
Joe Perches | 571f7f4 | 2010-10-21 22:17:17 -0700 | [diff] [blame] | 528 | EXOFS_ERR("write_exec: Failed to kmalloc(pcol)\n"); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 529 | ret = -ENOMEM; |
| 530 | goto err; |
| 531 | } |
| 532 | |
| 533 | *pcol_copy = *pcol; |
| 534 | |
Boaz Harrosh | e1042ba | 2010-11-16 20:09:58 +0200 | [diff] [blame] | 535 | ios = pcol->ios; |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 536 | ios->pages = pcol_copy->pages; |
| 537 | ios->nr_pages = pcol_copy->nr_pages; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 538 | ios->done = writepages_done; |
| 539 | ios->private = pcol_copy; |
| 540 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 541 | ret = exofs_sbi_write(ios); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 542 | if (unlikely(ret)) { |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 543 | EXOFS_ERR("write_exec: exofs_sbi_write() Failed\n"); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 544 | goto err; |
| 545 | } |
| 546 | |
| 547 | atomic_inc(&pcol->sbi->s_curr_pending); |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 548 | EXOFS_DBGMSG2("write_exec(0x%lx, 0x%llx) start=0x%llx length=0x%lx\n", |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 549 | pcol->inode->i_ino, pcol->pg_first, _LLU(ios->offset), |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 550 | pcol->length); |
| 551 | /* pages ownership was passed to pcol_copy */ |
| 552 | _pcol_reset(pcol); |
| 553 | return 0; |
| 554 | |
| 555 | err: |
| 556 | _unlock_pcol_pages(pcol, ret, WRITE); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 557 | pcol_free(pcol); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 558 | kfree(pcol_copy); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 559 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 560 | return ret; |
| 561 | } |
| 562 | |
| 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. |
| 569 | */ |
| 570 | static int writepage_strip(struct page *page, |
| 571 | struct writeback_control *wbc_unused, void *data) |
| 572 | { |
| 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; |
| 578 | size_t len; |
| 579 | int ret; |
| 580 | |
| 581 | BUG_ON(!PageLocked(page)); |
| 582 | |
| 583 | ret = wait_obj_created(oi); |
| 584 | if (unlikely(ret)) |
| 585 | goto fail; |
| 586 | |
| 587 | if (page->index < end_index) |
| 588 | /* in this case, the page is within the limits of the file */ |
| 589 | len = PAGE_CACHE_SIZE; |
| 590 | else { |
| 591 | len = i_size & ~PAGE_CACHE_MASK; |
| 592 | |
| 593 | if (page->index > end_index || !len) { |
| 594 | /* in this case, the page is outside the limits |
| 595 | * (truncate in progress) |
| 596 | */ |
| 597 | ret = write_exec(pcol); |
| 598 | if (unlikely(ret)) |
| 599 | goto fail; |
| 600 | if (PageError(page)) |
| 601 | ClearPageError(page); |
| 602 | unlock_page(page); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 603 | EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) " |
| 604 | "outside the limits\n", |
| 605 | inode->i_ino, page->index); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 606 | return 0; |
| 607 | } |
| 608 | } |
| 609 | |
| 610 | try_again: |
| 611 | |
| 612 | if (unlikely(pcol->pg_first == -1)) { |
| 613 | pcol->pg_first = page->index; |
| 614 | } else if (unlikely((pcol->pg_first + pcol->nr_pages) != |
| 615 | page->index)) { |
| 616 | /* Discontinuity detected, split the request */ |
| 617 | ret = write_exec(pcol); |
| 618 | if (unlikely(ret)) |
| 619 | goto fail; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 620 | |
| 621 | EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) Discontinuity\n", |
| 622 | inode->i_ino, page->index); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 623 | goto try_again; |
| 624 | } |
| 625 | |
Boaz Harrosh | 86093aa | 2010-01-28 18:24:06 +0200 | [diff] [blame] | 626 | if (!pcol->pages) { |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 627 | ret = pcol_try_alloc(pcol); |
| 628 | if (unlikely(ret)) |
| 629 | goto fail; |
| 630 | } |
| 631 | |
Boaz Harrosh | fe33cc1 | 2009-11-01 18:28:14 +0200 | [diff] [blame] | 632 | EXOFS_DBGMSG2(" writepage_strip(0x%lx, 0x%lx) len=0x%zx\n", |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 633 | inode->i_ino, page->index, len); |
| 634 | |
| 635 | ret = pcol_add_page(pcol, page, len); |
| 636 | if (unlikely(ret)) { |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 637 | EXOFS_DBGMSG2("Failed pcol_add_page " |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 638 | "nr_pages=%u total_length=0x%lx\n", |
| 639 | pcol->nr_pages, pcol->length); |
| 640 | |
| 641 | /* split the request, next loop will start again */ |
| 642 | ret = write_exec(pcol); |
| 643 | if (unlikely(ret)) { |
Joe Perches | 571f7f4 | 2010-10-21 22:17:17 -0700 | [diff] [blame] | 644 | EXOFS_DBGMSG("write_exec failed => %d", ret); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 645 | goto fail; |
| 646 | } |
| 647 | |
| 648 | goto try_again; |
| 649 | } |
| 650 | |
| 651 | BUG_ON(PageWriteback(page)); |
| 652 | set_page_writeback(page); |
| 653 | |
| 654 | return 0; |
| 655 | |
| 656 | fail: |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 657 | EXOFS_DBGMSG("Error: writepage_strip(0x%lx, 0x%lx)=>%d\n", |
| 658 | inode->i_ino, page->index, ret); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 659 | set_bit(AS_EIO, &page->mapping->flags); |
| 660 | unlock_page(page); |
| 661 | return ret; |
| 662 | } |
| 663 | |
| 664 | static int exofs_writepages(struct address_space *mapping, |
| 665 | struct writeback_control *wbc) |
| 666 | { |
| 667 | struct page_collect pcol; |
| 668 | long start, end, expected_pages; |
| 669 | int ret; |
| 670 | |
| 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; |
| 675 | |
| 676 | if (start || end) |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 677 | expected_pages = end - start + 1; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 678 | else |
| 679 | expected_pages = mapping->nrpages; |
| 680 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 681 | if (expected_pages < 32L) |
| 682 | expected_pages = 32L; |
| 683 | |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 684 | EXOFS_DBGMSG2("inode(0x%lx) wbc->start=0x%llx wbc->end=0x%llx " |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 685 | "nrpages=%lu start=0x%lx end=0x%lx expected_pages=%ld\n", |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 686 | mapping->host->i_ino, wbc->range_start, wbc->range_end, |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 687 | mapping->nrpages, start, end, expected_pages); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 688 | |
| 689 | _pcol_init(&pcol, expected_pages, mapping->host); |
| 690 | |
| 691 | ret = write_cache_pages(mapping, wbc, writepage_strip, &pcol); |
| 692 | if (ret) { |
| 693 | EXOFS_ERR("write_cache_pages => %d\n", ret); |
| 694 | return ret; |
| 695 | } |
| 696 | |
| 697 | return write_exec(&pcol); |
| 698 | } |
| 699 | |
| 700 | static int exofs_writepage(struct page *page, struct writeback_control *wbc) |
| 701 | { |
| 702 | struct page_collect pcol; |
| 703 | int ret; |
| 704 | |
| 705 | _pcol_init(&pcol, 1, page->mapping->host); |
| 706 | |
| 707 | ret = writepage_strip(page, NULL, &pcol); |
| 708 | if (ret) { |
| 709 | EXOFS_ERR("exofs_writepage => %d\n", ret); |
| 710 | return ret; |
| 711 | } |
| 712 | |
| 713 | return write_exec(&pcol); |
| 714 | } |
| 715 | |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 716 | /* i_mutex held using inode->i_size directly */ |
| 717 | static void _write_failed(struct inode *inode, loff_t to) |
| 718 | { |
| 719 | if (to > inode->i_size) |
| 720 | truncate_pagecache(inode, to, inode->i_size); |
| 721 | } |
| 722 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 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) |
| 726 | { |
| 727 | int ret = 0; |
| 728 | struct page *page; |
| 729 | |
| 730 | page = *pagep; |
| 731 | if (page == NULL) { |
| 732 | ret = simple_write_begin(file, mapping, pos, len, flags, pagep, |
| 733 | fsdata); |
| 734 | if (ret) { |
Joe Perches | 571f7f4 | 2010-10-21 22:17:17 -0700 | [diff] [blame] | 735 | EXOFS_DBGMSG("simple_write_begin failed\n"); |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 736 | goto out; |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 737 | } |
| 738 | |
| 739 | page = *pagep; |
| 740 | } |
| 741 | |
| 742 | /* read modify write */ |
| 743 | if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) { |
Boaz Harrosh | a8f1418 | 2010-11-22 18:02:45 +0200 | [diff] [blame] | 744 | loff_t i_size = i_size_read(mapping->host); |
| 745 | pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT; |
| 746 | size_t rlen; |
| 747 | |
| 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; |
| 752 | else |
| 753 | rlen = 0; |
| 754 | |
| 755 | if (!rlen) { |
| 756 | clear_highpage(page); |
| 757 | SetPageUptodate(page); |
| 758 | goto out; |
| 759 | } |
| 760 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 761 | ret = _readpage(page, true); |
| 762 | if (ret) { |
| 763 | /*SetPageError was done by _readpage. Is it ok?*/ |
| 764 | unlock_page(page); |
Boaz Harrosh | a8f1418 | 2010-11-22 18:02:45 +0200 | [diff] [blame] | 765 | EXOFS_DBGMSG("__readpage failed\n"); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 766 | } |
| 767 | } |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 768 | out: |
| 769 | if (unlikely(ret)) |
| 770 | _write_failed(mapping->host, pos + len); |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 771 | |
| 772 | return ret; |
| 773 | } |
| 774 | |
| 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) |
| 779 | { |
| 780 | *pagep = NULL; |
| 781 | |
| 782 | return exofs_write_begin(file, mapping, pos, len, flags, pagep, |
| 783 | fsdata); |
| 784 | } |
| 785 | |
Boaz Harrosh | efd124b | 2009-12-27 17:01:42 +0200 | [diff] [blame] | 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) |
| 789 | { |
| 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; |
| 793 | int ret; |
| 794 | |
| 795 | ret = simple_write_end(file, mapping,pos, len, copied, page, fsdata); |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 796 | if (unlikely(ret)) |
| 797 | _write_failed(inode, pos + len); |
| 798 | |
| 799 | /* TODO: once simple_write_end marks inode dirty remove */ |
Boaz Harrosh | efd124b | 2009-12-27 17:01:42 +0200 | [diff] [blame] | 800 | if (i_size != inode->i_size) |
| 801 | mark_inode_dirty(inode); |
| 802 | return ret; |
| 803 | } |
| 804 | |
Boaz Harrosh | 200b070 | 2010-03-22 11:23:40 +0200 | [diff] [blame] | 805 | static int exofs_releasepage(struct page *page, gfp_t gfp) |
| 806 | { |
| 807 | EXOFS_DBGMSG("page 0x%lx\n", page->index); |
| 808 | WARN_ON(1); |
Boaz Harrosh | 85dc787 | 2010-05-31 18:55:43 +0300 | [diff] [blame] | 809 | return 0; |
Boaz Harrosh | 200b070 | 2010-03-22 11:23:40 +0200 | [diff] [blame] | 810 | } |
| 811 | |
| 812 | static void exofs_invalidatepage(struct page *page, unsigned long offset) |
| 813 | { |
Boaz Harrosh | 85dc787 | 2010-05-31 18:55:43 +0300 | [diff] [blame] | 814 | EXOFS_DBGMSG("page 0x%lx offset 0x%lx\n", page->index, offset); |
Boaz Harrosh | 200b070 | 2010-03-22 11:23:40 +0200 | [diff] [blame] | 815 | WARN_ON(1); |
Boaz Harrosh | 200b070 | 2010-03-22 11:23:40 +0200 | [diff] [blame] | 816 | } |
| 817 | |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 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, |
Boaz Harrosh | efd124b | 2009-12-27 17:01:42 +0200 | [diff] [blame] | 824 | .write_end = exofs_write_end, |
Boaz Harrosh | 200b070 | 2010-03-22 11:23:40 +0200 | [diff] [blame] | 825 | .releasepage = exofs_releasepage, |
| 826 | .set_page_dirty = __set_page_dirty_nobuffers, |
| 827 | .invalidatepage = exofs_invalidatepage, |
| 828 | |
| 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 */ |
| 832 | |
| 833 | /* With these NULL has special meaning or default is not exported */ |
Boaz Harrosh | 200b070 | 2010-03-22 11:23:40 +0200 | [diff] [blame] | 834 | .get_xip_mem = NULL, |
| 835 | .migratepage = NULL, |
| 836 | .launder_page = NULL, |
| 837 | .is_partially_uptodate = NULL, |
| 838 | .error_remove_page = NULL, |
Boaz Harrosh | beaec07 | 2008-10-27 19:31:34 +0200 | [diff] [blame] | 839 | }; |
| 840 | |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 841 | /****************************************************************************** |
| 842 | * INODE OPERATIONS |
| 843 | *****************************************************************************/ |
| 844 | |
| 845 | /* |
| 846 | * Test whether an inode is a fast symlink. |
| 847 | */ |
| 848 | static inline int exofs_inode_is_fast_symlink(struct inode *inode) |
| 849 | { |
| 850 | struct exofs_i_info *oi = exofs_i(inode); |
| 851 | |
| 852 | return S_ISLNK(inode->i_mode) && (oi->i_data[0] != 0); |
| 853 | } |
| 854 | |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 855 | static int _do_truncate(struct inode *inode, loff_t newsize) |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 856 | { |
| 857 | struct exofs_i_info *oi = exofs_i(inode); |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 858 | struct exofs_sb_info *sbi = inode->i_sb->s_fs_info; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 859 | int ret; |
| 860 | |
| 861 | inode->i_mtime = inode->i_ctime = CURRENT_TIME; |
| 862 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 863 | ret = exofs_truncate(&sbi->layout, &oi->comps, (u64)newsize); |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 864 | if (likely(!ret)) |
| 865 | truncate_setsize(inode, newsize); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 866 | |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 867 | EXOFS_DBGMSG("(0x%lx) size=0x%llx ret=>%d\n", |
| 868 | inode->i_ino, newsize, ret); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 869 | return ret; |
| 870 | } |
| 871 | |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 872 | /* |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 873 | * Set inode attributes - update size attribute on OSD if needed, |
| 874 | * otherwise just call generic functions. |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 875 | */ |
| 876 | int exofs_setattr(struct dentry *dentry, struct iattr *iattr) |
| 877 | { |
| 878 | struct inode *inode = dentry->d_inode; |
| 879 | int error; |
| 880 | |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 881 | /* if we are about to modify an object, and it hasn't been |
| 882 | * created yet, wait |
| 883 | */ |
| 884 | error = wait_obj_created(exofs_i(inode)); |
| 885 | if (unlikely(error)) |
| 886 | return error; |
| 887 | |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 888 | error = inode_change_ok(inode, iattr); |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 889 | if (unlikely(error)) |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 890 | return error; |
| 891 | |
Christoph Hellwig | 1025774 | 2010-06-04 11:30:02 +0200 | [diff] [blame] | 892 | if ((iattr->ia_valid & ATTR_SIZE) && |
| 893 | iattr->ia_size != i_size_read(inode)) { |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 894 | error = _do_truncate(inode, iattr->ia_size); |
| 895 | if (unlikely(error)) |
Christoph Hellwig | 1025774 | 2010-06-04 11:30:02 +0200 | [diff] [blame] | 896 | return error; |
| 897 | } |
| 898 | |
| 899 | setattr_copy(inode, iattr); |
| 900 | mark_inode_dirty(inode); |
| 901 | return 0; |
Boaz Harrosh | e806271 | 2008-10-27 18:37:02 +0200 | [diff] [blame] | 902 | } |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 903 | |
Boaz Harrosh | d9c740d | 2010-01-28 11:58:08 +0200 | [diff] [blame] | 904 | static const struct osd_attr g_attr_inode_file_layout = ATTR_DEF( |
| 905 | EXOFS_APAGE_FS_DATA, |
| 906 | EXOFS_ATTR_INODE_FILE_LAYOUT, |
| 907 | 0); |
| 908 | static const struct osd_attr g_attr_inode_dir_layout = ATTR_DEF( |
| 909 | EXOFS_APAGE_FS_DATA, |
| 910 | EXOFS_ATTR_INODE_DIR_LAYOUT, |
| 911 | 0); |
| 912 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 913 | /* |
Boaz Harrosh | 5d952b8 | 2010-02-01 13:35:51 +0200 | [diff] [blame] | 914 | * Read the Linux inode info from the OSD, and return it as is. In exofs the |
| 915 | * inode info is in an application specific page/attribute of the osd-object. |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 916 | */ |
| 917 | static int exofs_get_inode(struct super_block *sb, struct exofs_i_info *oi, |
Boaz Harrosh | 5d952b8 | 2010-02-01 13:35:51 +0200 | [diff] [blame] | 918 | struct exofs_fcb *inode) |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 919 | { |
| 920 | struct exofs_sb_info *sbi = sb->s_fs_info; |
Boaz Harrosh | d9c740d | 2010-01-28 11:58:08 +0200 | [diff] [blame] | 921 | struct osd_attr attrs[] = { |
| 922 | [0] = g_attr_inode_data, |
| 923 | [1] = g_attr_inode_file_layout, |
| 924 | [2] = g_attr_inode_dir_layout, |
Boaz Harrosh | d9c740d | 2010-01-28 11:58:08 +0200 | [diff] [blame] | 925 | }; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 926 | struct exofs_io_state *ios; |
Boaz Harrosh | d9c740d | 2010-01-28 11:58:08 +0200 | [diff] [blame] | 927 | struct exofs_on_disk_inode_layout *layout; |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 928 | int ret; |
| 929 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 930 | ret = exofs_get_io_state(&sbi->layout, &oi->comps, &ios); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 931 | if (unlikely(ret)) { |
| 932 | EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__); |
| 933 | return ret; |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 934 | } |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 935 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 936 | attrs[1].len = exofs_on_disk_inode_layout_size(sbi->comps.numdevs); |
| 937 | attrs[2].len = exofs_on_disk_inode_layout_size(sbi->comps.numdevs); |
Boaz Harrosh | d9c740d | 2010-01-28 11:58:08 +0200 | [diff] [blame] | 938 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 939 | ios->in_attr = attrs; |
| 940 | ios->in_attr_len = ARRAY_SIZE(attrs); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 941 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 942 | ret = exofs_sbi_read(ios); |
Boaz Harrosh | 96391e2 | 2010-02-09 11:43:21 +0200 | [diff] [blame] | 943 | if (unlikely(ret)) { |
| 944 | EXOFS_ERR("object(0x%llx) corrupted, return empty file=>%d\n", |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 945 | _LLU(oi->one_comp.obj.id), ret); |
Boaz Harrosh | 96391e2 | 2010-02-09 11:43:21 +0200 | [diff] [blame] | 946 | memset(inode, 0, sizeof(*inode)); |
| 947 | inode->i_mode = 0040000 | (0777 & ~022); |
| 948 | /* If object is lost on target we might as well enable it's |
| 949 | * delete. |
| 950 | */ |
| 951 | if ((ret == -ENOENT) || (ret == -EINVAL)) |
| 952 | ret = 0; |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 953 | goto out; |
Boaz Harrosh | 96391e2 | 2010-02-09 11:43:21 +0200 | [diff] [blame] | 954 | } |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 955 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 956 | ret = extract_attr_from_ios(ios, &attrs[0]); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 957 | if (ret) { |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 958 | EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 959 | goto out; |
| 960 | } |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 961 | WARN_ON(attrs[0].len != EXOFS_INO_ATTR_SIZE); |
| 962 | memcpy(inode, attrs[0].val_ptr, EXOFS_INO_ATTR_SIZE); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 963 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 964 | ret = extract_attr_from_ios(ios, &attrs[1]); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 965 | if (ret) { |
Boaz Harrosh | d9c740d | 2010-01-28 11:58:08 +0200 | [diff] [blame] | 966 | EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__); |
| 967 | goto out; |
| 968 | } |
| 969 | if (attrs[1].len) { |
| 970 | layout = attrs[1].val_ptr; |
| 971 | if (layout->gen_func != cpu_to_le16(LAYOUT_MOVING_WINDOW)) { |
| 972 | EXOFS_ERR("%s: unsupported files layout %d\n", |
| 973 | __func__, layout->gen_func); |
| 974 | ret = -ENOTSUPP; |
| 975 | goto out; |
| 976 | } |
| 977 | } |
| 978 | |
| 979 | ret = extract_attr_from_ios(ios, &attrs[2]); |
| 980 | if (ret) { |
| 981 | EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__); |
| 982 | goto out; |
| 983 | } |
| 984 | if (attrs[2].len) { |
| 985 | layout = attrs[2].val_ptr; |
| 986 | if (layout->gen_func != cpu_to_le16(LAYOUT_MOVING_WINDOW)) { |
| 987 | EXOFS_ERR("%s: unsupported meta-data layout %d\n", |
| 988 | __func__, layout->gen_func); |
| 989 | ret = -ENOTSUPP; |
| 990 | goto out; |
| 991 | } |
| 992 | } |
| 993 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 994 | out: |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 995 | exofs_put_io_state(ios); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 996 | return ret; |
| 997 | } |
| 998 | |
Boaz Harrosh | 9cfdc7a | 2009-08-04 20:40:29 +0300 | [diff] [blame] | 999 | static void __oi_init(struct exofs_i_info *oi) |
| 1000 | { |
| 1001 | init_waitqueue_head(&oi->i_wq); |
| 1002 | oi->i_flags = 0; |
| 1003 | } |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1004 | /* |
| 1005 | * Fill in an inode read from the OSD and set it up for use |
| 1006 | */ |
| 1007 | struct inode *exofs_iget(struct super_block *sb, unsigned long ino) |
| 1008 | { |
| 1009 | struct exofs_i_info *oi; |
| 1010 | struct exofs_fcb fcb; |
| 1011 | struct inode *inode; |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1012 | int ret; |
| 1013 | |
| 1014 | inode = iget_locked(sb, ino); |
| 1015 | if (!inode) |
| 1016 | return ERR_PTR(-ENOMEM); |
| 1017 | if (!(inode->i_state & I_NEW)) |
| 1018 | return inode; |
| 1019 | oi = exofs_i(inode); |
Boaz Harrosh | 9cfdc7a | 2009-08-04 20:40:29 +0300 | [diff] [blame] | 1020 | __oi_init(oi); |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1021 | exofs_init_comps(&oi->comps, &oi->one_comp, sb->s_fs_info, |
| 1022 | exofs_oi_objno(oi)); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1023 | |
| 1024 | /* read the inode from the osd */ |
Boaz Harrosh | 5d952b8 | 2010-02-01 13:35:51 +0200 | [diff] [blame] | 1025 | ret = exofs_get_inode(sb, oi, &fcb); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1026 | if (ret) |
| 1027 | goto bad_inode; |
| 1028 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1029 | set_obj_created(oi); |
| 1030 | |
| 1031 | /* copy stuff from on-disk struct to in-memory struct */ |
| 1032 | inode->i_mode = le16_to_cpu(fcb.i_mode); |
| 1033 | inode->i_uid = le32_to_cpu(fcb.i_uid); |
| 1034 | inode->i_gid = le32_to_cpu(fcb.i_gid); |
| 1035 | inode->i_nlink = le16_to_cpu(fcb.i_links_count); |
| 1036 | inode->i_ctime.tv_sec = (signed)le32_to_cpu(fcb.i_ctime); |
| 1037 | inode->i_atime.tv_sec = (signed)le32_to_cpu(fcb.i_atime); |
| 1038 | inode->i_mtime.tv_sec = (signed)le32_to_cpu(fcb.i_mtime); |
| 1039 | inode->i_ctime.tv_nsec = |
| 1040 | inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = 0; |
| 1041 | oi->i_commit_size = le64_to_cpu(fcb.i_size); |
| 1042 | i_size_write(inode, oi->i_commit_size); |
| 1043 | inode->i_blkbits = EXOFS_BLKSHIFT; |
| 1044 | inode->i_generation = le32_to_cpu(fcb.i_generation); |
| 1045 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1046 | oi->i_dir_start_lookup = 0; |
| 1047 | |
| 1048 | if ((inode->i_nlink == 0) && (inode->i_mode == 0)) { |
| 1049 | ret = -ESTALE; |
| 1050 | goto bad_inode; |
| 1051 | } |
| 1052 | |
| 1053 | if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { |
| 1054 | if (fcb.i_data[0]) |
| 1055 | inode->i_rdev = |
| 1056 | old_decode_dev(le32_to_cpu(fcb.i_data[0])); |
| 1057 | else |
| 1058 | inode->i_rdev = |
| 1059 | new_decode_dev(le32_to_cpu(fcb.i_data[1])); |
| 1060 | } else { |
| 1061 | memcpy(oi->i_data, fcb.i_data, sizeof(fcb.i_data)); |
| 1062 | } |
| 1063 | |
bharrosh@panasas.com | 66cd6ca | 2010-10-07 14:28:18 -0400 | [diff] [blame] | 1064 | inode->i_mapping->backing_dev_info = sb->s_bdi; |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1065 | if (S_ISREG(inode->i_mode)) { |
| 1066 | inode->i_op = &exofs_file_inode_operations; |
| 1067 | inode->i_fop = &exofs_file_operations; |
| 1068 | inode->i_mapping->a_ops = &exofs_aops; |
| 1069 | } else if (S_ISDIR(inode->i_mode)) { |
| 1070 | inode->i_op = &exofs_dir_inode_operations; |
| 1071 | inode->i_fop = &exofs_dir_operations; |
| 1072 | inode->i_mapping->a_ops = &exofs_aops; |
| 1073 | } else if (S_ISLNK(inode->i_mode)) { |
| 1074 | if (exofs_inode_is_fast_symlink(inode)) |
| 1075 | inode->i_op = &exofs_fast_symlink_inode_operations; |
| 1076 | else { |
| 1077 | inode->i_op = &exofs_symlink_inode_operations; |
| 1078 | inode->i_mapping->a_ops = &exofs_aops; |
| 1079 | } |
| 1080 | } else { |
| 1081 | inode->i_op = &exofs_special_inode_operations; |
| 1082 | if (fcb.i_data[0]) |
| 1083 | init_special_inode(inode, inode->i_mode, |
| 1084 | old_decode_dev(le32_to_cpu(fcb.i_data[0]))); |
| 1085 | else |
| 1086 | init_special_inode(inode, inode->i_mode, |
| 1087 | new_decode_dev(le32_to_cpu(fcb.i_data[1]))); |
| 1088 | } |
| 1089 | |
| 1090 | unlock_new_inode(inode); |
| 1091 | return inode; |
| 1092 | |
| 1093 | bad_inode: |
| 1094 | iget_failed(inode); |
| 1095 | return ERR_PTR(ret); |
| 1096 | } |
| 1097 | |
| 1098 | int __exofs_wait_obj_created(struct exofs_i_info *oi) |
| 1099 | { |
| 1100 | if (!obj_created(oi)) { |
Boaz Harrosh | fe2fd9e | 2010-10-16 19:14:01 +1100 | [diff] [blame] | 1101 | EXOFS_DBGMSG("!obj_created\n"); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1102 | BUG_ON(!obj_2bcreated(oi)); |
| 1103 | wait_event(oi->i_wq, obj_created(oi)); |
Boaz Harrosh | fe2fd9e | 2010-10-16 19:14:01 +1100 | [diff] [blame] | 1104 | EXOFS_DBGMSG("wait_event done\n"); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1105 | } |
| 1106 | return unlikely(is_bad_inode(&oi->vfs_inode)) ? -EIO : 0; |
| 1107 | } |
Boaz Harrosh | 1cea312 | 2011-02-03 17:53:25 +0200 | [diff] [blame] | 1108 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1109 | /* |
| 1110 | * Callback function from exofs_new_inode(). The important thing is that we |
| 1111 | * set the obj_created flag so that other methods know that the object exists on |
| 1112 | * the OSD. |
| 1113 | */ |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1114 | static void create_done(struct exofs_io_state *ios, void *p) |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1115 | { |
| 1116 | struct inode *inode = p; |
| 1117 | struct exofs_i_info *oi = exofs_i(inode); |
| 1118 | struct exofs_sb_info *sbi = inode->i_sb->s_fs_info; |
| 1119 | int ret; |
| 1120 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1121 | ret = exofs_check_io(ios, NULL); |
| 1122 | exofs_put_io_state(ios); |
| 1123 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1124 | atomic_dec(&sbi->s_curr_pending); |
| 1125 | |
| 1126 | if (unlikely(ret)) { |
Joe Perches | 571f7f4 | 2010-10-21 22:17:17 -0700 | [diff] [blame] | 1127 | EXOFS_ERR("object=0x%llx creation failed in pid=0x%llx", |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1128 | _LLU(exofs_oi_objno(oi)), |
| 1129 | _LLU(oi->one_comp.obj.partition)); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1130 | /*TODO: When FS is corrupted creation can fail, object already |
| 1131 | * exist. Get rid of this asynchronous creation, if exist |
| 1132 | * increment the obj counter and try the next object. Until we |
| 1133 | * succeed. All these dangling objects will be made into lost |
| 1134 | * files by chkfs.exofs |
| 1135 | */ |
| 1136 | } |
| 1137 | |
| 1138 | set_obj_created(oi); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1139 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1140 | wake_up(&oi->i_wq); |
| 1141 | } |
| 1142 | |
| 1143 | /* |
| 1144 | * Set up a new inode and create an object for it on the OSD |
| 1145 | */ |
| 1146 | struct inode *exofs_new_inode(struct inode *dir, int mode) |
| 1147 | { |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1148 | struct super_block *sb = dir->i_sb; |
| 1149 | struct exofs_sb_info *sbi = sb->s_fs_info; |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1150 | struct inode *inode; |
| 1151 | struct exofs_i_info *oi; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1152 | struct exofs_io_state *ios; |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1153 | int ret; |
| 1154 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1155 | inode = new_inode(sb); |
| 1156 | if (!inode) |
| 1157 | return ERR_PTR(-ENOMEM); |
| 1158 | |
| 1159 | oi = exofs_i(inode); |
Boaz Harrosh | 9cfdc7a | 2009-08-04 20:40:29 +0300 | [diff] [blame] | 1160 | __oi_init(oi); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1161 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1162 | set_obj_2bcreated(oi); |
| 1163 | |
bharrosh@panasas.com | 66cd6ca | 2010-10-07 14:28:18 -0400 | [diff] [blame] | 1164 | inode->i_mapping->backing_dev_info = sb->s_bdi; |
Dmitry Monakhov | e00117f | 2010-03-04 17:31:48 +0300 | [diff] [blame] | 1165 | inode_init_owner(inode, dir, mode); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1166 | inode->i_ino = sbi->s_nextid++; |
| 1167 | inode->i_blkbits = EXOFS_BLKSHIFT; |
| 1168 | inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME; |
| 1169 | oi->i_commit_size = inode->i_size = 0; |
| 1170 | spin_lock(&sbi->s_next_gen_lock); |
| 1171 | inode->i_generation = sbi->s_next_generation++; |
| 1172 | spin_unlock(&sbi->s_next_gen_lock); |
| 1173 | insert_inode_hash(inode); |
| 1174 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1175 | exofs_init_comps(&oi->comps, &oi->one_comp, sb->s_fs_info, |
| 1176 | exofs_oi_objno(oi)); |
Boaz Harrosh | 1cea312 | 2011-02-03 17:53:25 +0200 | [diff] [blame] | 1177 | exofs_sbi_write_stats(sbi); /* Make sure new sbi->s_nextid is on disk */ |
| 1178 | |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1179 | mark_inode_dirty(inode); |
| 1180 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1181 | ret = exofs_get_io_state(&sbi->layout, &oi->comps, &ios); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1182 | if (unlikely(ret)) { |
| 1183 | EXOFS_ERR("exofs_new_inode: exofs_get_io_state failed\n"); |
| 1184 | return ERR_PTR(ret); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1185 | } |
| 1186 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1187 | ios->done = create_done; |
| 1188 | ios->private = inode; |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1189 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1190 | ret = exofs_sbi_create(ios); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1191 | if (ret) { |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1192 | exofs_put_io_state(ios); |
| 1193 | return ERR_PTR(ret); |
Boaz Harrosh | e6af00f | 2008-10-28 15:38:12 +0200 | [diff] [blame] | 1194 | } |
| 1195 | atomic_inc(&sbi->s_curr_pending); |
| 1196 | |
| 1197 | return inode; |
| 1198 | } |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1199 | |
| 1200 | /* |
| 1201 | * struct to pass two arguments to update_inode's callback |
| 1202 | */ |
| 1203 | struct updatei_args { |
| 1204 | struct exofs_sb_info *sbi; |
| 1205 | struct exofs_fcb fcb; |
| 1206 | }; |
| 1207 | |
| 1208 | /* |
| 1209 | * Callback function from exofs_update_inode(). |
| 1210 | */ |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1211 | static void updatei_done(struct exofs_io_state *ios, void *p) |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1212 | { |
| 1213 | struct updatei_args *args = p; |
| 1214 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1215 | exofs_put_io_state(ios); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1216 | |
| 1217 | atomic_dec(&args->sbi->s_curr_pending); |
| 1218 | |
| 1219 | kfree(args); |
| 1220 | } |
| 1221 | |
| 1222 | /* |
| 1223 | * Write the inode to the OSD. Just fill up the struct, and set the attribute |
| 1224 | * synchronously or asynchronously depending on the do_sync flag. |
| 1225 | */ |
| 1226 | static int exofs_update_inode(struct inode *inode, int do_sync) |
| 1227 | { |
| 1228 | struct exofs_i_info *oi = exofs_i(inode); |
| 1229 | struct super_block *sb = inode->i_sb; |
| 1230 | struct exofs_sb_info *sbi = sb->s_fs_info; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1231 | struct exofs_io_state *ios; |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1232 | struct osd_attr attr; |
| 1233 | struct exofs_fcb *fcb; |
| 1234 | struct updatei_args *args; |
| 1235 | int ret; |
| 1236 | |
| 1237 | args = kzalloc(sizeof(*args), GFP_KERNEL); |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 1238 | if (!args) { |
Joe Perches | 571f7f4 | 2010-10-21 22:17:17 -0700 | [diff] [blame] | 1239 | EXOFS_DBGMSG("Failed kzalloc of args\n"); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1240 | return -ENOMEM; |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 1241 | } |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1242 | |
| 1243 | fcb = &args->fcb; |
| 1244 | |
| 1245 | fcb->i_mode = cpu_to_le16(inode->i_mode); |
| 1246 | fcb->i_uid = cpu_to_le32(inode->i_uid); |
| 1247 | fcb->i_gid = cpu_to_le32(inode->i_gid); |
| 1248 | fcb->i_links_count = cpu_to_le16(inode->i_nlink); |
| 1249 | fcb->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec); |
| 1250 | fcb->i_atime = cpu_to_le32(inode->i_atime.tv_sec); |
| 1251 | fcb->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec); |
| 1252 | oi->i_commit_size = i_size_read(inode); |
| 1253 | fcb->i_size = cpu_to_le64(oi->i_commit_size); |
| 1254 | fcb->i_generation = cpu_to_le32(inode->i_generation); |
| 1255 | |
| 1256 | if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) { |
| 1257 | if (old_valid_dev(inode->i_rdev)) { |
| 1258 | fcb->i_data[0] = |
| 1259 | cpu_to_le32(old_encode_dev(inode->i_rdev)); |
| 1260 | fcb->i_data[1] = 0; |
| 1261 | } else { |
| 1262 | fcb->i_data[0] = 0; |
| 1263 | fcb->i_data[1] = |
| 1264 | cpu_to_le32(new_encode_dev(inode->i_rdev)); |
| 1265 | fcb->i_data[2] = 0; |
| 1266 | } |
| 1267 | } else |
| 1268 | memcpy(fcb->i_data, oi->i_data, sizeof(fcb->i_data)); |
| 1269 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1270 | ret = exofs_get_io_state(&sbi->layout, &oi->comps, &ios); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1271 | if (unlikely(ret)) { |
| 1272 | EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1273 | goto free_args; |
| 1274 | } |
| 1275 | |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1276 | attr = g_attr_inode_data; |
| 1277 | attr.val_ptr = fcb; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1278 | ios->out_attr_len = 1; |
| 1279 | ios->out_attr = &attr; |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1280 | |
Boaz Harrosh | fe2fd9e | 2010-10-16 19:14:01 +1100 | [diff] [blame] | 1281 | wait_obj_created(oi); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1282 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1283 | if (!do_sync) { |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1284 | args->sbi = sbi; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1285 | ios->done = updatei_done; |
| 1286 | ios->private = args; |
| 1287 | } |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1288 | |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1289 | ret = exofs_sbi_write(ios); |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1290 | if (!do_sync && !ret) { |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1291 | atomic_inc(&sbi->s_curr_pending); |
| 1292 | goto out; /* deallocation in updatei_done */ |
| 1293 | } |
| 1294 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1295 | exofs_put_io_state(ios); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1296 | free_args: |
| 1297 | kfree(args); |
| 1298 | out: |
Boaz Harrosh | 34ce4e7 | 2009-12-15 19:34:17 +0200 | [diff] [blame] | 1299 | EXOFS_DBGMSG("(0x%lx) do_sync=%d ret=>%d\n", |
| 1300 | inode->i_ino, do_sync, ret); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1301 | return ret; |
| 1302 | } |
| 1303 | |
Christoph Hellwig | a9185b4 | 2010-03-05 09:21:37 +0100 | [diff] [blame] | 1304 | int exofs_write_inode(struct inode *inode, struct writeback_control *wbc) |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1305 | { |
Nick Piggin | 97178b7 | 2010-11-25 12:47:15 +0200 | [diff] [blame] | 1306 | /* FIXME: fix fsync and use wbc->sync_mode == WB_SYNC_ALL */ |
| 1307 | return exofs_update_inode(inode, 1); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1308 | } |
| 1309 | |
| 1310 | /* |
| 1311 | * Callback function from exofs_delete_inode() - don't have much cleaning up to |
| 1312 | * do. |
| 1313 | */ |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1314 | static void delete_done(struct exofs_io_state *ios, void *p) |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1315 | { |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1316 | struct exofs_sb_info *sbi = p; |
| 1317 | |
| 1318 | exofs_put_io_state(ios); |
| 1319 | |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1320 | atomic_dec(&sbi->s_curr_pending); |
| 1321 | } |
| 1322 | |
| 1323 | /* |
| 1324 | * Called when the refcount of an inode reaches zero. We remove the object |
| 1325 | * from the OSD here. We make sure the object was created before we try and |
| 1326 | * delete it. |
| 1327 | */ |
Al Viro | 4ec70c9 | 2010-06-07 11:42:26 -0400 | [diff] [blame] | 1328 | void exofs_evict_inode(struct inode *inode) |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1329 | { |
| 1330 | struct exofs_i_info *oi = exofs_i(inode); |
| 1331 | struct super_block *sb = inode->i_sb; |
| 1332 | struct exofs_sb_info *sbi = sb->s_fs_info; |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1333 | struct exofs_io_state *ios; |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1334 | int ret; |
| 1335 | |
| 1336 | truncate_inode_pages(&inode->i_data, 0); |
| 1337 | |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 1338 | /* TODO: should do better here */ |
Al Viro | 4ec70c9 | 2010-06-07 11:42:26 -0400 | [diff] [blame] | 1339 | if (inode->i_nlink || is_bad_inode(inode)) |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1340 | goto no_delete; |
| 1341 | |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1342 | inode->i_size = 0; |
Al Viro | 4ec70c9 | 2010-06-07 11:42:26 -0400 | [diff] [blame] | 1343 | end_writeback(inode); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1344 | |
Boaz Harrosh | fe2fd9e | 2010-10-16 19:14:01 +1100 | [diff] [blame] | 1345 | /* if we are deleting an obj that hasn't been created yet, wait. |
| 1346 | * This also makes sure that create_done cannot be called with an |
| 1347 | * already evicted inode. |
| 1348 | */ |
| 1349 | wait_obj_created(oi); |
| 1350 | /* ignore the error, attempt a remove anyway */ |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 1351 | |
| 1352 | /* Now Remove the OSD objects */ |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1353 | ret = exofs_get_io_state(&sbi->layout, &oi->comps, &ios); |
Boaz Harrosh | 2f246fd | 2010-06-09 18:23:18 +0300 | [diff] [blame] | 1354 | if (unlikely(ret)) { |
| 1355 | EXOFS_ERR("%s: exofs_get_io_state failed\n", __func__); |
| 1356 | return; |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1357 | } |
| 1358 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1359 | ios->done = delete_done; |
| 1360 | ios->private = sbi; |
Boaz Harrosh | 9e9db45 | 2011-08-05 15:06:04 -0700 | [diff] [blame^] | 1361 | |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1362 | ret = exofs_sbi_remove(ios); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1363 | if (ret) { |
Boaz Harrosh | 06886a5 | 2009-11-08 14:54:08 +0200 | [diff] [blame] | 1364 | EXOFS_ERR("%s: exofs_sbi_remove failed\n", __func__); |
| 1365 | exofs_put_io_state(ios); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1366 | return; |
| 1367 | } |
| 1368 | atomic_inc(&sbi->s_curr_pending); |
| 1369 | |
| 1370 | return; |
| 1371 | |
| 1372 | no_delete: |
Al Viro | 4ec70c9 | 2010-06-07 11:42:26 -0400 | [diff] [blame] | 1373 | end_writeback(inode); |
Boaz Harrosh | ba9e5e9 | 2008-10-28 16:11:41 +0200 | [diff] [blame] | 1374 | } |