inode.c 36.6 KB
Newer Older
1 2
/*
 * Copyright (C) 2005, 2006
B
Boaz Harrosh 已提交
3
 * Avishay Traeger (avishay@gmail.com)
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 * Copyright (C) 2008, 2009
 * Boaz Harrosh <bharrosh@panasas.com>
 *
 * Copyrights for code taken from ext2:
 *     Copyright (C) 1992, 1993, 1994, 1995
 *     Remy Card (card@masi.ibp.fr)
 *     Laboratoire MASI - Institut Blaise Pascal
 *     Universite Pierre et Marie Curie (Paris VI)
 *     from
 *     linux/fs/minix/inode.c
 *     Copyright (C) 1991, 1992  Linus Torvalds
 *
 * This file is part of exofs.
 *
 * exofs is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation.  Since it is based on ext2, and the only
 * valid version of GPL for the Linux kernel is version 2, the only valid
 * version of GPL for exofs is version 2.
 *
 * exofs is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with exofs; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

34
#include <linux/slab.h>
35 36 37

#include "exofs.h"

B
Boaz Harrosh 已提交
38 39
#define EXOFS_DBGMSG2(M...) do {} while (0)

40
enum {MAX_PAGES_KMALLOC = PAGE_SIZE / sizeof(struct page *), };
41

42
unsigned exofs_max_io_pages(struct ore_layout *layout,
43 44 45 46 47
			    unsigned expected_pages)
{
	unsigned pages = min_t(unsigned, expected_pages, MAX_PAGES_KMALLOC);

	/* TODO: easily support bio chaining */
48
	pages =  min_t(unsigned, pages, layout->max_io_length / PAGE_SIZE);
49 50 51
	return pages;
}

B
Boaz Harrosh 已提交
52 53 54 55
struct page_collect {
	struct exofs_sb_info *sbi;
	struct inode *inode;
	unsigned expected_pages;
56
	struct ore_io_state *ios;
B
Boaz Harrosh 已提交
57

58 59
	struct page **pages;
	unsigned alloc_pages;
B
Boaz Harrosh 已提交
60 61 62
	unsigned nr_pages;
	unsigned long length;
	loff_t pg_first; /* keep 64bit also in 32-arches */
63 64 65
	bool read_4_write; /* This means two things: that the read is sync
			    * And the pages should not be unlocked.
			    */
66
	struct page *that_locked_page;
B
Boaz Harrosh 已提交
67 68 69
};

static void _pcol_init(struct page_collect *pcol, unsigned expected_pages,
70
		       struct inode *inode)
B
Boaz Harrosh 已提交
71 72 73 74 75 76 77
{
	struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;

	pcol->sbi = sbi;
	pcol->inode = inode;
	pcol->expected_pages = expected_pages;

78
	pcol->ios = NULL;
79 80
	pcol->pages = NULL;
	pcol->alloc_pages = 0;
B
Boaz Harrosh 已提交
81 82 83
	pcol->nr_pages = 0;
	pcol->length = 0;
	pcol->pg_first = -1;
84
	pcol->read_4_write = false;
85
	pcol->that_locked_page = NULL;
B
Boaz Harrosh 已提交
86 87 88 89 90 91
}

static void _pcol_reset(struct page_collect *pcol)
{
	pcol->expected_pages -= min(pcol->nr_pages, pcol->expected_pages);

92 93
	pcol->pages = NULL;
	pcol->alloc_pages = 0;
B
Boaz Harrosh 已提交
94 95 96
	pcol->nr_pages = 0;
	pcol->length = 0;
	pcol->pg_first = -1;
97
	pcol->ios = NULL;
98
	pcol->that_locked_page = NULL;
B
Boaz Harrosh 已提交
99 100 101 102 103

	/* this is probably the end of the loop but in writes
	 * it might not end here. don't be left with nothing
	 */
	if (!pcol->expected_pages)
104
		pcol->expected_pages = MAX_PAGES_KMALLOC;
B
Boaz Harrosh 已提交
105 106 107 108
}

static int pcol_try_alloc(struct page_collect *pcol)
{
109
	unsigned pages;
110

111
	/* TODO: easily support bio chaining */
112
	pages =  exofs_max_io_pages(&pcol->sbi->layout, pcol->expected_pages);
113

B
Boaz Harrosh 已提交
114
	for (; pages; pages >>= 1) {
115 116 117 118
		pcol->pages = kmalloc(pages * sizeof(struct page *),
				      GFP_KERNEL);
		if (likely(pcol->pages)) {
			pcol->alloc_pages = pages;
B
Boaz Harrosh 已提交
119
			return 0;
120
		}
B
Boaz Harrosh 已提交
121 122
	}

123
	EXOFS_ERR("Failed to kmalloc expected_pages=%u\n",
B
Boaz Harrosh 已提交
124 125 126 127 128 129
		  pcol->expected_pages);
	return -ENOMEM;
}

static void pcol_free(struct page_collect *pcol)
{
130 131
	kfree(pcol->pages);
	pcol->pages = NULL;
132 133

	if (pcol->ios) {
134
		ore_put_io_state(pcol->ios);
135 136
		pcol->ios = NULL;
	}
B
Boaz Harrosh 已提交
137 138 139 140 141
}

static int pcol_add_page(struct page_collect *pcol, struct page *page,
			 unsigned len)
{
142
	if (unlikely(pcol->nr_pages >= pcol->alloc_pages))
B
Boaz Harrosh 已提交
143 144
		return -ENOMEM;

145
	pcol->pages[pcol->nr_pages++] = page;
B
Boaz Harrosh 已提交
146 147 148 149
	pcol->length += len;
	return 0;
}

150
enum {PAGE_WAS_NOT_IN_IO = 17};
B
Boaz Harrosh 已提交
151 152
static int update_read_page(struct page *page, int ret)
{
153 154
	switch (ret) {
	case 0:
B
Boaz Harrosh 已提交
155 156 157 158
		/* Everything is OK */
		SetPageUptodate(page);
		if (PageError(page))
			ClearPageError(page);
159 160
		break;
	case -EFAULT:
B
Boaz Harrosh 已提交
161 162 163 164 165 166 167 168 169 170 171
		/* In this case we were trying to read something that wasn't on
		 * disk yet - return a page full of zeroes.  This should be OK,
		 * because the object should be empty (if there was a write
		 * before this read, the read would be waiting with the page
		 * locked */
		clear_highpage(page);

		SetPageUptodate(page);
		if (PageError(page))
			ClearPageError(page);
		EXOFS_DBGMSG("recovered read error\n");
172 173 174 175 176
		/* fall through */
	case PAGE_WAS_NOT_IN_IO:
		ret = 0; /* recovered error */
		break;
	default:
B
Boaz Harrosh 已提交
177
		SetPageError(page);
178
	}
B
Boaz Harrosh 已提交
179 180 181 182 183
	return ret;
}

static void update_write_page(struct page *page, int ret)
{
184 185 186
	if (unlikely(ret == PAGE_WAS_NOT_IN_IO))
		return; /* don't pass start don't collect $200 */

B
Boaz Harrosh 已提交
187 188 189 190 191 192 193 194 195 196
	if (ret) {
		mapping_set_error(page->mapping, ret);
		SetPageError(page);
	}
	end_page_writeback(page);
}

/* Called at the end of reads, to optionally unlock pages and update their
 * status.
 */
197
static int __readpages_done(struct page_collect *pcol)
B
Boaz Harrosh 已提交
198 199 200 201
{
	int i;
	u64 good_bytes;
	u64 length = 0;
B
Boaz Harrosh 已提交
202
	int ret = ore_check_io(pcol->ios, NULL);
B
Boaz Harrosh 已提交
203

204
	if (likely(!ret)) {
B
Boaz Harrosh 已提交
205
		good_bytes = pcol->length;
206 207
		ret = PAGE_WAS_NOT_IN_IO;
	} else {
B
Boaz Harrosh 已提交
208
		good_bytes = 0;
209
	}
B
Boaz Harrosh 已提交
210

B
Boaz Harrosh 已提交
211
	EXOFS_DBGMSG2("readpages_done(0x%lx) good_bytes=0x%llx"
B
Boaz Harrosh 已提交
212 213 214 215
		     " length=0x%lx nr_pages=%u\n",
		     pcol->inode->i_ino, _LLU(good_bytes), pcol->length,
		     pcol->nr_pages);

216 217
	for (i = 0; i < pcol->nr_pages; i++) {
		struct page *page = pcol->pages[i];
B
Boaz Harrosh 已提交
218 219 220 221 222 223 224 225 226 227 228
		struct inode *inode = page->mapping->host;
		int page_stat;

		if (inode != pcol->inode)
			continue; /* osd might add more pages at end */

		if (likely(length < good_bytes))
			page_stat = 0;
		else
			page_stat = ret;

B
Boaz Harrosh 已提交
229
		EXOFS_DBGMSG2("    readpages_done(0x%lx, 0x%lx) %s\n",
B
Boaz Harrosh 已提交
230 231 232 233
			  inode->i_ino, page->index,
			  page_stat ? "bad_bytes" : "good_bytes");

		ret = update_read_page(page, page_stat);
234
		if (!pcol->read_4_write)
B
Boaz Harrosh 已提交
235
			unlock_page(page);
236
		length += PAGE_SIZE;
B
Boaz Harrosh 已提交
237 238 239
	}

	pcol_free(pcol);
B
Boaz Harrosh 已提交
240
	EXOFS_DBGMSG2("readpages_done END\n");
B
Boaz Harrosh 已提交
241 242 243 244
	return ret;
}

/* callback of async reads */
245
static void readpages_done(struct ore_io_state *ios, void *p)
B
Boaz Harrosh 已提交
246 247 248
{
	struct page_collect *pcol = p;

249
	__readpages_done(pcol);
B
Boaz Harrosh 已提交
250
	atomic_dec(&pcol->sbi->s_curr_pending);
251
	kfree(pcol);
B
Boaz Harrosh 已提交
252 253 254 255 256 257
}

static void _unlock_pcol_pages(struct page_collect *pcol, int ret, int rw)
{
	int i;

258 259
	for (i = 0; i < pcol->nr_pages; i++) {
		struct page *page = pcol->pages[i];
B
Boaz Harrosh 已提交
260 261 262 263 264 265 266 267 268 269

		if (rw == READ)
			update_read_page(page, ret);
		else
			update_write_page(page, ret);

		unlock_page(page);
	}
}

270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
static int _maybe_not_all_in_one_io(struct ore_io_state *ios,
	struct page_collect *pcol_src, struct page_collect *pcol)
{
	/* length was wrong or offset was not page aligned */
	BUG_ON(pcol_src->nr_pages < ios->nr_pages);

	if (pcol_src->nr_pages > ios->nr_pages) {
		struct page **src_page;
		unsigned pages_less = pcol_src->nr_pages - ios->nr_pages;
		unsigned long len_less = pcol_src->length - ios->length;
		unsigned i;
		int ret;

		/* This IO was trimmed */
		pcol_src->nr_pages = ios->nr_pages;
		pcol_src->length = ios->length;

		/* Left over pages are passed to the next io */
		pcol->expected_pages += pages_less;
		pcol->nr_pages = pages_less;
		pcol->length = len_less;
		src_page = pcol_src->pages + pcol_src->nr_pages;
		pcol->pg_first = (*src_page)->index;

		ret = pcol_try_alloc(pcol);
		if (unlikely(ret))
			return ret;

		for (i = 0; i < pages_less; ++i)
			pcol->pages[i] = *src_page++;

		EXOFS_DBGMSG("Length was adjusted nr_pages=0x%x "
			"pages_less=0x%x expected_pages=0x%x "
			"next_offset=0x%llx next_len=0x%lx\n",
			pcol_src->nr_pages, pages_less, pcol->expected_pages,
			pcol->pg_first * PAGE_SIZE, pcol->length);
	}
	return 0;
}

310
static int read_exec(struct page_collect *pcol)
B
Boaz Harrosh 已提交
311 312
{
	struct exofs_i_info *oi = exofs_i(pcol->inode);
313
	struct ore_io_state *ios;
B
Boaz Harrosh 已提交
314 315 316
	struct page_collect *pcol_copy = NULL;
	int ret;

317
	if (!pcol->pages)
B
Boaz Harrosh 已提交
318 319
		return 0;

320
	if (!pcol->ios) {
321
		int ret = ore_get_rw_state(&pcol->sbi->layout, &oi->oc, true,
322 323 324 325 326 327 328 329
					     pcol->pg_first << PAGE_CACHE_SHIFT,
					     pcol->length, &pcol->ios);

		if (ret)
			return ret;
	}

	ios = pcol->ios;
330
	ios->pages = pcol->pages;
B
Boaz Harrosh 已提交
331

332
	if (pcol->read_4_write) {
333
		ore_read(pcol->ios);
334
		return __readpages_done(pcol);
B
Boaz Harrosh 已提交
335 336 337 338 339 340 341 342 343
	}

	pcol_copy = kmalloc(sizeof(*pcol_copy), GFP_KERNEL);
	if (!pcol_copy) {
		ret = -ENOMEM;
		goto err;
	}

	*pcol_copy = *pcol;
344 345
	ios->done = readpages_done;
	ios->private = pcol_copy;
346 347 348 349 350 351 352 353 354 355 356

	/* pages ownership was passed to pcol_copy */
	_pcol_reset(pcol);

	ret = _maybe_not_all_in_one_io(ios, pcol_copy, pcol);
	if (unlikely(ret))
		goto err;

	EXOFS_DBGMSG2("read_exec(0x%lx) offset=0x%llx length=0x%llx\n",
		pcol->inode->i_ino, _LLU(ios->offset), _LLU(ios->length));

357
	ret = ore_read(ios);
B
Boaz Harrosh 已提交
358 359 360 361 362 363 364 365
	if (unlikely(ret))
		goto err;

	atomic_inc(&pcol->sbi->s_curr_pending);

	return 0;

err:
366
	if (!pcol->read_4_write)
B
Boaz Harrosh 已提交
367
		_unlock_pcol_pages(pcol, ret, READ);
368 369

	pcol_free(pcol);
370

B
Boaz Harrosh 已提交
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
	kfree(pcol_copy);
	return ret;
}

/* readpage_strip is called either directly from readpage() or by the VFS from
 * within read_cache_pages(), to add one more page to be read. It will try to
 * collect as many contiguous pages as posible. If a discontinuity is
 * encountered, or it runs out of resources, it will submit the previous segment
 * and will start a new collection. Eventually caller must submit the last
 * segment if present.
 */
static int readpage_strip(void *data, struct page *page)
{
	struct page_collect *pcol = data;
	struct inode *inode = pcol->inode;
	struct exofs_i_info *oi = exofs_i(inode);
	loff_t i_size = i_size_read(inode);
	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
	size_t len;
	int ret;

392 393
	BUG_ON(!PageLocked(page));

B
Boaz Harrosh 已提交
394 395 396 397 398
	/* FIXME: Just for debugging, will be removed */
	if (PageUptodate(page))
		EXOFS_ERR("PageUptodate(0x%lx, 0x%lx)\n", pcol->inode->i_ino,
			  page->index);

399 400
	pcol->that_locked_page = page;

B
Boaz Harrosh 已提交
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
	if (page->index < end_index)
		len = PAGE_CACHE_SIZE;
	else if (page->index == end_index)
		len = i_size & ~PAGE_CACHE_MASK;
	else
		len = 0;

	if (!len || !obj_created(oi)) {
		/* this will be out of bounds, or doesn't exist yet.
		 * Current page is cleared and the request is split
		 */
		clear_highpage(page);

		SetPageUptodate(page);
		if (PageError(page))
			ClearPageError(page);

418 419
		if (!pcol->read_4_write)
			unlock_page(page);
B
Boaz Harrosh 已提交
420 421 422 423
		EXOFS_DBGMSG("readpage_strip(0x%lx) empty page len=%zx "
			     "read_4_write=%d index=0x%lx end_index=0x%lx "
			     "splitting\n", inode->i_ino, len,
			     pcol->read_4_write, page->index, end_index);
B
Boaz Harrosh 已提交
424

425
		return read_exec(pcol);
B
Boaz Harrosh 已提交
426 427 428 429 430 431 432 433 434
	}

try_again:

	if (unlikely(pcol->pg_first == -1)) {
		pcol->pg_first = page->index;
	} else if (unlikely((pcol->pg_first + pcol->nr_pages) !=
		   page->index)) {
		/* Discontinuity detected, split the request */
435
		ret = read_exec(pcol);
B
Boaz Harrosh 已提交
436 437 438 439 440
		if (unlikely(ret))
			goto fail;
		goto try_again;
	}

441
	if (!pcol->pages) {
B
Boaz Harrosh 已提交
442 443 444 445 446 447 448 449
		ret = pcol_try_alloc(pcol);
		if (unlikely(ret))
			goto fail;
	}

	if (len != PAGE_CACHE_SIZE)
		zero_user(page, len, PAGE_CACHE_SIZE - len);

B
Boaz Harrosh 已提交
450
	EXOFS_DBGMSG2("    readpage_strip(0x%lx, 0x%lx) len=0x%zx\n",
B
Boaz Harrosh 已提交
451 452 453 454
		     inode->i_ino, page->index, len);

	ret = pcol_add_page(pcol, page, len);
	if (ret) {
B
Boaz Harrosh 已提交
455
		EXOFS_DBGMSG2("Failed pcol_add_page pages[i]=%p "
B
Boaz Harrosh 已提交
456 457 458 459
			  "this_len=0x%zx nr_pages=%u length=0x%lx\n",
			  page, len, pcol->nr_pages, pcol->length);

		/* split the request, and start again with current page */
460
		ret = read_exec(pcol);
B
Boaz Harrosh 已提交
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
		if (unlikely(ret))
			goto fail;

		goto try_again;
	}

	return 0;

fail:
	/* SetPageError(page); ??? */
	unlock_page(page);
	return ret;
}

static int exofs_readpages(struct file *file, struct address_space *mapping,
			   struct list_head *pages, unsigned nr_pages)
{
	struct page_collect pcol;
	int ret;

	_pcol_init(&pcol, nr_pages, mapping->host);

	ret = read_cache_pages(mapping, pages, readpage_strip, &pcol);
	if (ret) {
		EXOFS_ERR("read_cache_pages => %d\n", ret);
		return ret;
	}

489 490 491 492
	ret = read_exec(&pcol);
	if (unlikely(ret))
		return ret;

493
	return read_exec(&pcol);
B
Boaz Harrosh 已提交
494 495
}

496
static int _readpage(struct page *page, bool read_4_write)
B
Boaz Harrosh 已提交
497 498 499 500 501 502
{
	struct page_collect pcol;
	int ret;

	_pcol_init(&pcol, 1, page->mapping->host);

503
	pcol.read_4_write = read_4_write;
B
Boaz Harrosh 已提交
504 505 506 507 508 509
	ret = readpage_strip(&pcol, page);
	if (ret) {
		EXOFS_ERR("_readpage => %d\n", ret);
		return ret;
	}

510
	return read_exec(&pcol);
B
Boaz Harrosh 已提交
511 512 513 514 515 516 517 518 519 520
}

/*
 * We don't need the file
 */
static int exofs_readpage(struct file *file, struct page *page)
{
	return _readpage(page, false);
}

521
/* Callback for osd_write. All writes are asynchronous */
522
static void writepages_done(struct ore_io_state *ios, void *p)
B
Boaz Harrosh 已提交
523 524 525 526 527
{
	struct page_collect *pcol = p;
	int i;
	u64  good_bytes;
	u64  length = 0;
B
Boaz Harrosh 已提交
528
	int ret = ore_check_io(ios, NULL);
B
Boaz Harrosh 已提交
529 530 531

	atomic_dec(&pcol->sbi->s_curr_pending);

532
	if (likely(!ret)) {
B
Boaz Harrosh 已提交
533
		good_bytes = pcol->length;
534 535
		ret = PAGE_WAS_NOT_IN_IO;
	} else {
B
Boaz Harrosh 已提交
536
		good_bytes = 0;
537
	}
B
Boaz Harrosh 已提交
538

B
Boaz Harrosh 已提交
539
	EXOFS_DBGMSG2("writepages_done(0x%lx) good_bytes=0x%llx"
B
Boaz Harrosh 已提交
540 541 542 543
		     " length=0x%lx nr_pages=%u\n",
		     pcol->inode->i_ino, _LLU(good_bytes), pcol->length,
		     pcol->nr_pages);

544 545
	for (i = 0; i < pcol->nr_pages; i++) {
		struct page *page = pcol->pages[i];
B
Boaz Harrosh 已提交
546 547 548 549 550 551 552 553 554 555 556 557 558
		struct inode *inode = page->mapping->host;
		int page_stat;

		if (inode != pcol->inode)
			continue; /* osd might add more pages to a bio */

		if (likely(length < good_bytes))
			page_stat = 0;
		else
			page_stat = ret;

		update_write_page(page, page_stat);
		unlock_page(page);
B
Boaz Harrosh 已提交
559
		EXOFS_DBGMSG2("    writepages_done(0x%lx, 0x%lx) status=%d\n",
B
Boaz Harrosh 已提交
560 561
			     inode->i_ino, page->index, page_stat);

562
		length += PAGE_SIZE;
B
Boaz Harrosh 已提交
563 564 565 566
	}

	pcol_free(pcol);
	kfree(pcol);
B
Boaz Harrosh 已提交
567
	EXOFS_DBGMSG2("writepages_done END\n");
B
Boaz Harrosh 已提交
568 569
}

570 571 572 573 574 575 576
static struct page *__r4w_get_page(void *priv, u64 offset, bool *uptodate)
{
	struct page_collect *pcol = priv;
	pgoff_t index = offset / PAGE_SIZE;

	if (!pcol->that_locked_page ||
	    (pcol->that_locked_page->index != index)) {
577 578
		struct page *page;
		loff_t i_size = i_size_read(pcol->inode);
579

580 581 582 583 584 585 586
		if (offset >= i_size) {
			*uptodate = true;
			EXOFS_DBGMSG("offset >= i_size index=0x%lx\n", index);
			return ZERO_PAGE(0);
		}

		page =  find_get_page(pcol->inode->i_mapping, index);
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
		if (!page) {
			page = find_or_create_page(pcol->inode->i_mapping,
						   index, GFP_NOFS);
			if (unlikely(!page)) {
				EXOFS_DBGMSG("grab_cache_page Failed "
					"index=0x%llx\n", _LLU(index));
				return NULL;
			}
			unlock_page(page);
		}
		if (PageDirty(page) || PageWriteback(page))
			*uptodate = true;
		else
			*uptodate = PageUptodate(page);
		EXOFS_DBGMSG("index=0x%lx uptodate=%d\n", index, *uptodate);
		return page;
	} else {
		EXOFS_DBGMSG("YES that_locked_page index=0x%lx\n",
			     pcol->that_locked_page->index);
		*uptodate = true;
		return pcol->that_locked_page;
	}
}

static void __r4w_put_page(void *priv, struct page *page)
{
	struct page_collect *pcol = priv;

615
	if ((pcol->that_locked_page != page) && (ZERO_PAGE(0) != page)) {
616 617 618 619
		EXOFS_DBGMSG("index=0x%lx\n", page->index);
		page_cache_release(page);
		return;
	}
620 621
	EXOFS_DBGMSG("that_locked_page index=0x%lx\n",
		     ZERO_PAGE(0) == page ? -1 : page->index);
622 623 624 625 626 627 628
}

static const struct _ore_r4w_op _r4w_op = {
	.get_page = &__r4w_get_page,
	.put_page = &__r4w_put_page,
};

B
Boaz Harrosh 已提交
629 630 631
static int write_exec(struct page_collect *pcol)
{
	struct exofs_i_info *oi = exofs_i(pcol->inode);
632
	struct ore_io_state *ios;
B
Boaz Harrosh 已提交
633 634 635
	struct page_collect *pcol_copy = NULL;
	int ret;

636
	if (!pcol->pages)
B
Boaz Harrosh 已提交
637 638
		return 0;

639
	BUG_ON(pcol->ios);
640
	ret = ore_get_rw_state(&pcol->sbi->layout, &oi->oc, false,
641 642 643 644 645
				 pcol->pg_first << PAGE_CACHE_SHIFT,
				 pcol->length, &pcol->ios);
	if (unlikely(ret))
		goto err;

B
Boaz Harrosh 已提交
646 647
	pcol_copy = kmalloc(sizeof(*pcol_copy), GFP_KERNEL);
	if (!pcol_copy) {
648
		EXOFS_ERR("write_exec: Failed to kmalloc(pcol)\n");
B
Boaz Harrosh 已提交
649 650 651 652 653 654
		ret = -ENOMEM;
		goto err;
	}

	*pcol_copy = *pcol;

655
	ios = pcol->ios;
656
	ios->pages = pcol_copy->pages;
657
	ios->done = writepages_done;
658
	ios->r4w = &_r4w_op;
659 660
	ios->private = pcol_copy;

661 662 663 664 665 666 667 668 669 670
	/* pages ownership was passed to pcol_copy */
	_pcol_reset(pcol);

	ret = _maybe_not_all_in_one_io(ios, pcol_copy, pcol);
	if (unlikely(ret))
		goto err;

	EXOFS_DBGMSG2("write_exec(0x%lx) offset=0x%llx length=0x%llx\n",
		pcol->inode->i_ino, _LLU(ios->offset), _LLU(ios->length));

671
	ret = ore_write(ios);
B
Boaz Harrosh 已提交
672
	if (unlikely(ret)) {
673
		EXOFS_ERR("write_exec: ore_write() Failed\n");
B
Boaz Harrosh 已提交
674 675 676 677 678 679 680 681
		goto err;
	}

	atomic_inc(&pcol->sbi->s_curr_pending);
	return 0;

err:
	_unlock_pcol_pages(pcol, ret, WRITE);
682
	pcol_free(pcol);
B
Boaz Harrosh 已提交
683
	kfree(pcol_copy);
684

B
Boaz Harrosh 已提交
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
	return ret;
}

/* writepage_strip is called either directly from writepage() or by the VFS from
 * within write_cache_pages(), to add one more page to be written to storage.
 * It will try to collect as many contiguous pages as possible. If a
 * discontinuity is encountered or it runs out of resources it will submit the
 * previous segment and will start a new collection.
 * Eventually caller must submit the last segment if present.
 */
static int writepage_strip(struct page *page,
			   struct writeback_control *wbc_unused, void *data)
{
	struct page_collect *pcol = data;
	struct inode *inode = pcol->inode;
	struct exofs_i_info *oi = exofs_i(inode);
	loff_t i_size = i_size_read(inode);
	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
	size_t len;
	int ret;

	BUG_ON(!PageLocked(page));

	ret = wait_obj_created(oi);
	if (unlikely(ret))
		goto fail;

	if (page->index < end_index)
		/* in this case, the page is within the limits of the file */
		len = PAGE_CACHE_SIZE;
	else {
		len = i_size & ~PAGE_CACHE_MASK;

		if (page->index > end_index || !len) {
			/* in this case, the page is outside the limits
			 * (truncate in progress)
			 */
			ret = write_exec(pcol);
			if (unlikely(ret))
				goto fail;
			if (PageError(page))
				ClearPageError(page);
			unlock_page(page);
728 729 730
			EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) "
				     "outside the limits\n",
				     inode->i_ino, page->index);
B
Boaz Harrosh 已提交
731 732 733 734 735 736 737 738 739 740 741 742 743 744
			return 0;
		}
	}

try_again:

	if (unlikely(pcol->pg_first == -1)) {
		pcol->pg_first = page->index;
	} else if (unlikely((pcol->pg_first + pcol->nr_pages) !=
		   page->index)) {
		/* Discontinuity detected, split the request */
		ret = write_exec(pcol);
		if (unlikely(ret))
			goto fail;
745 746 747

		EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) Discontinuity\n",
			     inode->i_ino, page->index);
B
Boaz Harrosh 已提交
748 749 750
		goto try_again;
	}

751
	if (!pcol->pages) {
B
Boaz Harrosh 已提交
752 753 754 755 756
		ret = pcol_try_alloc(pcol);
		if (unlikely(ret))
			goto fail;
	}

B
Boaz Harrosh 已提交
757
	EXOFS_DBGMSG2("    writepage_strip(0x%lx, 0x%lx) len=0x%zx\n",
B
Boaz Harrosh 已提交
758 759 760 761
		     inode->i_ino, page->index, len);

	ret = pcol_add_page(pcol, page, len);
	if (unlikely(ret)) {
B
Boaz Harrosh 已提交
762
		EXOFS_DBGMSG2("Failed pcol_add_page "
B
Boaz Harrosh 已提交
763 764 765 766 767 768
			     "nr_pages=%u total_length=0x%lx\n",
			     pcol->nr_pages, pcol->length);

		/* split the request, next loop will start again */
		ret = write_exec(pcol);
		if (unlikely(ret)) {
769
			EXOFS_DBGMSG("write_exec failed => %d", ret);
B
Boaz Harrosh 已提交
770 771 772 773 774 775 776 777 778 779 780 781
			goto fail;
		}

		goto try_again;
	}

	BUG_ON(PageWriteback(page));
	set_page_writeback(page);

	return 0;

fail:
782 783
	EXOFS_DBGMSG("Error: writepage_strip(0x%lx, 0x%lx)=>%d\n",
		     inode->i_ino, page->index, ret);
B
Boaz Harrosh 已提交
784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
	set_bit(AS_EIO, &page->mapping->flags);
	unlock_page(page);
	return ret;
}

static int exofs_writepages(struct address_space *mapping,
		       struct writeback_control *wbc)
{
	struct page_collect pcol;
	long start, end, expected_pages;
	int ret;

	start = wbc->range_start >> PAGE_CACHE_SHIFT;
	end = (wbc->range_end == LLONG_MAX) ?
			start + mapping->nrpages :
			wbc->range_end >> PAGE_CACHE_SHIFT;

	if (start || end)
802
		expected_pages = end - start + 1;
B
Boaz Harrosh 已提交
803 804 805
	else
		expected_pages = mapping->nrpages;

806 807 808
	if (expected_pages < 32L)
		expected_pages = 32L;

B
Boaz Harrosh 已提交
809
	EXOFS_DBGMSG2("inode(0x%lx) wbc->start=0x%llx wbc->end=0x%llx "
810
		     "nrpages=%lu start=0x%lx end=0x%lx expected_pages=%ld\n",
B
Boaz Harrosh 已提交
811
		     mapping->host->i_ino, wbc->range_start, wbc->range_end,
812
		     mapping->nrpages, start, end, expected_pages);
B
Boaz Harrosh 已提交
813 814 815 816

	_pcol_init(&pcol, expected_pages, mapping->host);

	ret = write_cache_pages(mapping, wbc, writepage_strip, &pcol);
817
	if (unlikely(ret)) {
B
Boaz Harrosh 已提交
818 819 820 821
		EXOFS_ERR("write_cache_pages => %d\n", ret);
		return ret;
	}

822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
	ret = write_exec(&pcol);
	if (unlikely(ret))
		return ret;

	if (wbc->sync_mode == WB_SYNC_ALL) {
		return write_exec(&pcol); /* pump the last reminder */
	} else if (pcol.nr_pages) {
		/* not SYNC let the reminder join the next writeout */
		unsigned i;

		for (i = 0; i < pcol.nr_pages; i++) {
			struct page *page = pcol.pages[i];

			end_page_writeback(page);
			set_page_dirty(page);
			unlock_page(page);
		}
	}
	return 0;
B
Boaz Harrosh 已提交
841 842
}

843
/*
B
Boaz Harrosh 已提交
844 845 846 847 848 849 850 851 852 853 854 855 856 857 858
static int exofs_writepage(struct page *page, struct writeback_control *wbc)
{
	struct page_collect pcol;
	int ret;

	_pcol_init(&pcol, 1, page->mapping->host);

	ret = writepage_strip(page, NULL, &pcol);
	if (ret) {
		EXOFS_ERR("exofs_writepage => %d\n", ret);
		return ret;
	}

	return write_exec(&pcol);
}
859
*/
B
Boaz Harrosh 已提交
860 861 862 863 864 865 866
/* i_mutex held using inode->i_size directly */
static void _write_failed(struct inode *inode, loff_t to)
{
	if (to > inode->i_size)
		truncate_pagecache(inode, to, inode->i_size);
}

B
Boaz Harrosh 已提交
867 868 869 870 871 872 873 874 875 876 877 878
int exofs_write_begin(struct file *file, struct address_space *mapping,
		loff_t pos, unsigned len, unsigned flags,
		struct page **pagep, void **fsdata)
{
	int ret = 0;
	struct page *page;

	page = *pagep;
	if (page == NULL) {
		ret = simple_write_begin(file, mapping, pos, len, flags, pagep,
					 fsdata);
		if (ret) {
879
			EXOFS_DBGMSG("simple_write_begin failed\n");
B
Boaz Harrosh 已提交
880
			goto out;
B
Boaz Harrosh 已提交
881 882 883 884 885 886 887
		}

		page = *pagep;
	}

	 /* read modify write */
	if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) {
B
Boaz Harrosh 已提交
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
		loff_t i_size = i_size_read(mapping->host);
		pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
		size_t rlen;

		if (page->index < end_index)
			rlen = PAGE_CACHE_SIZE;
		else if (page->index == end_index)
			rlen = i_size & ~PAGE_CACHE_MASK;
		else
			rlen = 0;

		if (!rlen) {
			clear_highpage(page);
			SetPageUptodate(page);
			goto out;
		}

B
Boaz Harrosh 已提交
905 906 907 908
		ret = _readpage(page, true);
		if (ret) {
			/*SetPageError was done by _readpage. Is it ok?*/
			unlock_page(page);
B
Boaz Harrosh 已提交
909
			EXOFS_DBGMSG("__readpage failed\n");
B
Boaz Harrosh 已提交
910 911
		}
	}
B
Boaz Harrosh 已提交
912 913 914
out:
	if (unlikely(ret))
		_write_failed(mapping->host, pos + len);
B
Boaz Harrosh 已提交
915 916 917 918 919 920 921 922 923 924 925 926 927 928 929

	return ret;
}

static int exofs_write_begin_export(struct file *file,
		struct address_space *mapping,
		loff_t pos, unsigned len, unsigned flags,
		struct page **pagep, void **fsdata)
{
	*pagep = NULL;

	return exofs_write_begin(file, mapping, pos, len, flags, pagep,
					fsdata);
}

930 931 932 933 934 935 936 937 938 939
static int exofs_write_end(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned copied,
			struct page *page, void *fsdata)
{
	struct inode *inode = mapping->host;
	/* According to comment in simple_write_end i_mutex is held */
	loff_t i_size = inode->i_size;
	int ret;

	ret = simple_write_end(file, mapping,pos, len, copied, page, fsdata);
B
Boaz Harrosh 已提交
940 941 942 943
	if (unlikely(ret))
		_write_failed(inode, pos + len);

	/* TODO: once simple_write_end marks inode dirty remove */
944 945 946 947 948
	if (i_size != inode->i_size)
		mark_inode_dirty(inode);
	return ret;
}

949 950 951 952
static int exofs_releasepage(struct page *page, gfp_t gfp)
{
	EXOFS_DBGMSG("page 0x%lx\n", page->index);
	WARN_ON(1);
953
	return 0;
954 955 956 957
}

static void exofs_invalidatepage(struct page *page, unsigned long offset)
{
958
	EXOFS_DBGMSG("page 0x%lx offset 0x%lx\n", page->index, offset);
959 960 961
	WARN_ON(1);
}

B
Boaz Harrosh 已提交
962 963 964
const struct address_space_operations exofs_aops = {
	.readpage	= exofs_readpage,
	.readpages	= exofs_readpages,
965
	.writepage	= NULL,
B
Boaz Harrosh 已提交
966 967
	.writepages	= exofs_writepages,
	.write_begin	= exofs_write_begin_export,
968
	.write_end	= exofs_write_end,
969 970 971 972 973 974 975 976 977 978 979 980 981 982
	.releasepage	= exofs_releasepage,
	.set_page_dirty	= __set_page_dirty_nobuffers,
	.invalidatepage = exofs_invalidatepage,

	/* Not implemented Yet */
	.bmap		= NULL, /* TODO: use osd's OSD_ACT_READ_MAP */
	.direct_IO	= NULL, /* TODO: Should be trivial to do */

	/* With these NULL has special meaning or default is not exported */
	.get_xip_mem	= NULL,
	.migratepage	= NULL,
	.launder_page	= NULL,
	.is_partially_uptodate = NULL,
	.error_remove_page = NULL,
B
Boaz Harrosh 已提交
983 984
};

985 986 987 988 989 990 991 992 993 994 995 996 997 998
/******************************************************************************
 * INODE OPERATIONS
 *****************************************************************************/

/*
 * Test whether an inode is a fast symlink.
 */
static inline int exofs_inode_is_fast_symlink(struct inode *inode)
{
	struct exofs_i_info *oi = exofs_i(inode);

	return S_ISLNK(inode->i_mode) && (oi->i_data[0] != 0);
}

B
Boaz Harrosh 已提交
999
static int _do_truncate(struct inode *inode, loff_t newsize)
1000 1001
{
	struct exofs_i_info *oi = exofs_i(inode);
1002
	struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;
1003 1004 1005 1006
	int ret;

	inode->i_mtime = inode->i_ctime = CURRENT_TIME;

1007
	ret = ore_truncate(&sbi->layout, &oi->oc, (u64)newsize);
B
Boaz Harrosh 已提交
1008 1009
	if (likely(!ret))
		truncate_setsize(inode, newsize);
1010

B
Boaz Harrosh 已提交
1011 1012
	EXOFS_DBGMSG("(0x%lx) size=0x%llx ret=>%d\n",
		     inode->i_ino, newsize, ret);
1013 1014 1015
	return ret;
}

1016
/*
B
Boaz Harrosh 已提交
1017 1018
 * Set inode attributes - update size attribute on OSD if needed,
 *                        otherwise just call generic functions.
1019 1020 1021 1022 1023 1024
 */
int exofs_setattr(struct dentry *dentry, struct iattr *iattr)
{
	struct inode *inode = dentry->d_inode;
	int error;

B
Boaz Harrosh 已提交
1025 1026 1027 1028 1029 1030 1031
	/* if we are about to modify an object, and it hasn't been
	 * created yet, wait
	 */
	error = wait_obj_created(exofs_i(inode));
	if (unlikely(error))
		return error;

1032
	error = inode_change_ok(inode, iattr);
B
Boaz Harrosh 已提交
1033
	if (unlikely(error))
1034 1035
		return error;

C
Christoph Hellwig 已提交
1036 1037
	if ((iattr->ia_valid & ATTR_SIZE) &&
	    iattr->ia_size != i_size_read(inode)) {
B
Boaz Harrosh 已提交
1038 1039
		error = _do_truncate(inode, iattr->ia_size);
		if (unlikely(error))
C
Christoph Hellwig 已提交
1040 1041 1042 1043 1044 1045
			return error;
	}

	setattr_copy(inode, iattr);
	mark_inode_dirty(inode);
	return 0;
1046
}
1047

1048 1049 1050 1051 1052 1053 1054 1055 1056
static const struct osd_attr g_attr_inode_file_layout = ATTR_DEF(
	EXOFS_APAGE_FS_DATA,
	EXOFS_ATTR_INODE_FILE_LAYOUT,
	0);
static const struct osd_attr g_attr_inode_dir_layout = ATTR_DEF(
	EXOFS_APAGE_FS_DATA,
	EXOFS_ATTR_INODE_DIR_LAYOUT,
	0);

1057
/*
B
Boaz Harrosh 已提交
1058 1059
 * Read the Linux inode info from the OSD, and return it as is. In exofs the
 * inode info is in an application specific page/attribute of the osd-object.
1060 1061
 */
static int exofs_get_inode(struct super_block *sb, struct exofs_i_info *oi,
B
Boaz Harrosh 已提交
1062
		    struct exofs_fcb *inode)
1063 1064
{
	struct exofs_sb_info *sbi = sb->s_fs_info;
1065 1066 1067 1068 1069
	struct osd_attr attrs[] = {
		[0] = g_attr_inode_data,
		[1] = g_attr_inode_file_layout,
		[2] = g_attr_inode_dir_layout,
	};
1070
	struct ore_io_state *ios;
1071
	struct exofs_on_disk_inode_layout *layout;
1072 1073
	int ret;

1074
	ret = ore_get_io_state(&sbi->layout, &oi->oc, &ios);
1075
	if (unlikely(ret)) {
1076
		EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
1077
		return ret;
1078 1079
	}

1080 1081
	attrs[1].len = exofs_on_disk_inode_layout_size(sbi->oc.numdevs);
	attrs[2].len = exofs_on_disk_inode_layout_size(sbi->oc.numdevs);
1082

1083 1084
	ios->in_attr = attrs;
	ios->in_attr_len = ARRAY_SIZE(attrs);
1085

1086
	ret = ore_read(ios);
1087 1088
	if (unlikely(ret)) {
		EXOFS_ERR("object(0x%llx) corrupted, return empty file=>%d\n",
1089
			  _LLU(oi->one_comp.obj.id), ret);
1090 1091 1092 1093 1094 1095 1096
		memset(inode, 0, sizeof(*inode));
		inode->i_mode = 0040000 | (0777 & ~022);
		/* If object is lost on target we might as well enable it's
		 * delete.
		 */
		if ((ret == -ENOENT) || (ret == -EINVAL))
			ret = 0;
1097
		goto out;
1098
	}
1099

1100
	ret = extract_attr_from_ios(ios, &attrs[0]);
1101
	if (ret) {
1102
		EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__);
1103 1104
		goto out;
	}
1105 1106
	WARN_ON(attrs[0].len != EXOFS_INO_ATTR_SIZE);
	memcpy(inode, attrs[0].val_ptr, EXOFS_INO_ATTR_SIZE);
1107

1108
	ret = extract_attr_from_ios(ios, &attrs[1]);
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
	if (ret) {
		EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__);
		goto out;
	}
	if (attrs[1].len) {
		layout = attrs[1].val_ptr;
		if (layout->gen_func != cpu_to_le16(LAYOUT_MOVING_WINDOW)) {
			EXOFS_ERR("%s: unsupported files layout %d\n",
				__func__, layout->gen_func);
			ret = -ENOTSUPP;
			goto out;
		}
	}

	ret = extract_attr_from_ios(ios, &attrs[2]);
	if (ret) {
		EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__);
		goto out;
	}
	if (attrs[2].len) {
		layout = attrs[2].val_ptr;
		if (layout->gen_func != cpu_to_le16(LAYOUT_MOVING_WINDOW)) {
			EXOFS_ERR("%s: unsupported meta-data layout %d\n",
				__func__, layout->gen_func);
			ret = -ENOTSUPP;
			goto out;
		}
	}

1138
out:
1139
	ore_put_io_state(ios);
1140 1141 1142
	return ret;
}

1143 1144 1145 1146 1147
static void __oi_init(struct exofs_i_info *oi)
{
	init_waitqueue_head(&oi->i_wq);
	oi->i_flags = 0;
}
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
/*
 * Fill in an inode read from the OSD and set it up for use
 */
struct inode *exofs_iget(struct super_block *sb, unsigned long ino)
{
	struct exofs_i_info *oi;
	struct exofs_fcb fcb;
	struct inode *inode;
	int ret;

	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;
	oi = exofs_i(inode);
1164
	__oi_init(oi);
1165
	exofs_init_comps(&oi->oc, &oi->one_comp, sb->s_fs_info,
1166
			 exofs_oi_objno(oi));
1167 1168

	/* read the inode from the osd */
B
Boaz Harrosh 已提交
1169
	ret = exofs_get_inode(sb, oi, &fcb);
1170 1171 1172 1173 1174 1175 1176 1177 1178
	if (ret)
		goto bad_inode;

	set_obj_created(oi);

	/* copy stuff from on-disk struct to in-memory struct */
	inode->i_mode = le16_to_cpu(fcb.i_mode);
	inode->i_uid = le32_to_cpu(fcb.i_uid);
	inode->i_gid = le32_to_cpu(fcb.i_gid);
M
Miklos Szeredi 已提交
1179
	set_nlink(inode, le16_to_cpu(fcb.i_links_count));
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
	inode->i_ctime.tv_sec = (signed)le32_to_cpu(fcb.i_ctime);
	inode->i_atime.tv_sec = (signed)le32_to_cpu(fcb.i_atime);
	inode->i_mtime.tv_sec = (signed)le32_to_cpu(fcb.i_mtime);
	inode->i_ctime.tv_nsec =
		inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = 0;
	oi->i_commit_size = le64_to_cpu(fcb.i_size);
	i_size_write(inode, oi->i_commit_size);
	inode->i_blkbits = EXOFS_BLKSHIFT;
	inode->i_generation = le32_to_cpu(fcb.i_generation);

	oi->i_dir_start_lookup = 0;

	if ((inode->i_nlink == 0) && (inode->i_mode == 0)) {
		ret = -ESTALE;
		goto bad_inode;
	}

	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
		if (fcb.i_data[0])
			inode->i_rdev =
				old_decode_dev(le32_to_cpu(fcb.i_data[0]));
		else
			inode->i_rdev =
				new_decode_dev(le32_to_cpu(fcb.i_data[1]));
	} else {
		memcpy(oi->i_data, fcb.i_data, sizeof(fcb.i_data));
	}

1208
	inode->i_mapping->backing_dev_info = sb->s_bdi;
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
	if (S_ISREG(inode->i_mode)) {
		inode->i_op = &exofs_file_inode_operations;
		inode->i_fop = &exofs_file_operations;
		inode->i_mapping->a_ops = &exofs_aops;
	} else if (S_ISDIR(inode->i_mode)) {
		inode->i_op = &exofs_dir_inode_operations;
		inode->i_fop = &exofs_dir_operations;
		inode->i_mapping->a_ops = &exofs_aops;
	} else if (S_ISLNK(inode->i_mode)) {
		if (exofs_inode_is_fast_symlink(inode))
			inode->i_op = &exofs_fast_symlink_inode_operations;
		else {
			inode->i_op = &exofs_symlink_inode_operations;
			inode->i_mapping->a_ops = &exofs_aops;
		}
	} else {
		inode->i_op = &exofs_special_inode_operations;
		if (fcb.i_data[0])
			init_special_inode(inode, inode->i_mode,
			   old_decode_dev(le32_to_cpu(fcb.i_data[0])));
		else
			init_special_inode(inode, inode->i_mode,
			   new_decode_dev(le32_to_cpu(fcb.i_data[1])));
	}

	unlock_new_inode(inode);
	return inode;

bad_inode:
	iget_failed(inode);
	return ERR_PTR(ret);
}

int __exofs_wait_obj_created(struct exofs_i_info *oi)
{
	if (!obj_created(oi)) {
1245
		EXOFS_DBGMSG("!obj_created\n");
1246 1247
		BUG_ON(!obj_2bcreated(oi));
		wait_event(oi->i_wq, obj_created(oi));
1248
		EXOFS_DBGMSG("wait_event done\n");
1249 1250 1251
	}
	return unlikely(is_bad_inode(&oi->vfs_inode)) ? -EIO : 0;
}
1252

1253 1254 1255 1256 1257
/*
 * Callback function from exofs_new_inode().  The important thing is that we
 * set the obj_created flag so that other methods know that the object exists on
 * the OSD.
 */
1258
static void create_done(struct ore_io_state *ios, void *p)
1259 1260 1261 1262 1263 1264
{
	struct inode *inode = p;
	struct exofs_i_info *oi = exofs_i(inode);
	struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;
	int ret;

1265 1266
	ret = ore_check_io(ios, NULL);
	ore_put_io_state(ios);
1267

1268 1269 1270
	atomic_dec(&sbi->s_curr_pending);

	if (unlikely(ret)) {
1271
		EXOFS_ERR("object=0x%llx creation failed in pid=0x%llx",
1272 1273
			  _LLU(exofs_oi_objno(oi)),
			  _LLU(oi->one_comp.obj.partition));
1274 1275 1276 1277 1278 1279 1280 1281 1282
		/*TODO: When FS is corrupted creation can fail, object already
		 * exist. Get rid of this asynchronous creation, if exist
		 * increment the obj counter and try the next object. Until we
		 * succeed. All these dangling objects will be made into lost
		 * files by chkfs.exofs
		 */
	}

	set_obj_created(oi);
1283 1284 1285 1286 1287 1288 1289

	wake_up(&oi->i_wq);
}

/*
 * Set up a new inode and create an object for it on the OSD
 */
A
Al Viro 已提交
1290
struct inode *exofs_new_inode(struct inode *dir, umode_t mode)
1291
{
1292 1293
	struct super_block *sb = dir->i_sb;
	struct exofs_sb_info *sbi = sb->s_fs_info;
1294 1295
	struct inode *inode;
	struct exofs_i_info *oi;
1296
	struct ore_io_state *ios;
1297 1298 1299 1300 1301 1302 1303
	int ret;

	inode = new_inode(sb);
	if (!inode)
		return ERR_PTR(-ENOMEM);

	oi = exofs_i(inode);
1304
	__oi_init(oi);
1305 1306 1307

	set_obj_2bcreated(oi);

1308
	inode->i_mapping->backing_dev_info = sb->s_bdi;
1309
	inode_init_owner(inode, dir, mode);
1310 1311 1312 1313 1314 1315 1316 1317 1318
	inode->i_ino = sbi->s_nextid++;
	inode->i_blkbits = EXOFS_BLKSHIFT;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	oi->i_commit_size = inode->i_size = 0;
	spin_lock(&sbi->s_next_gen_lock);
	inode->i_generation = sbi->s_next_generation++;
	spin_unlock(&sbi->s_next_gen_lock);
	insert_inode_hash(inode);

1319
	exofs_init_comps(&oi->oc, &oi->one_comp, sb->s_fs_info,
1320
			 exofs_oi_objno(oi));
1321 1322
	exofs_sbi_write_stats(sbi); /* Make sure new sbi->s_nextid is on disk */

1323 1324
	mark_inode_dirty(inode);

1325
	ret = ore_get_io_state(&sbi->layout, &oi->oc, &ios);
1326
	if (unlikely(ret)) {
1327
		EXOFS_ERR("exofs_new_inode: ore_get_io_state failed\n");
1328
		return ERR_PTR(ret);
1329 1330
	}

1331 1332
	ios->done = create_done;
	ios->private = inode;
1333

1334
	ret = ore_create(ios);
1335
	if (ret) {
1336
		ore_put_io_state(ios);
1337
		return ERR_PTR(ret);
1338 1339 1340 1341 1342
	}
	atomic_inc(&sbi->s_curr_pending);

	return inode;
}
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354

/*
 * struct to pass two arguments to update_inode's callback
 */
struct updatei_args {
	struct exofs_sb_info	*sbi;
	struct exofs_fcb	fcb;
};

/*
 * Callback function from exofs_update_inode().
 */
1355
static void updatei_done(struct ore_io_state *ios, void *p)
1356 1357 1358
{
	struct updatei_args *args = p;

1359
	ore_put_io_state(ios);
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374

	atomic_dec(&args->sbi->s_curr_pending);

	kfree(args);
}

/*
 * Write the inode to the OSD.  Just fill up the struct, and set the attribute
 * synchronously or asynchronously depending on the do_sync flag.
 */
static int exofs_update_inode(struct inode *inode, int do_sync)
{
	struct exofs_i_info *oi = exofs_i(inode);
	struct super_block *sb = inode->i_sb;
	struct exofs_sb_info *sbi = sb->s_fs_info;
1375
	struct ore_io_state *ios;
1376 1377 1378 1379 1380 1381
	struct osd_attr attr;
	struct exofs_fcb *fcb;
	struct updatei_args *args;
	int ret;

	args = kzalloc(sizeof(*args), GFP_KERNEL);
B
Boaz Harrosh 已提交
1382
	if (!args) {
1383
		EXOFS_DBGMSG("Failed kzalloc of args\n");
1384
		return -ENOMEM;
B
Boaz Harrosh 已提交
1385
	}
1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413

	fcb = &args->fcb;

	fcb->i_mode = cpu_to_le16(inode->i_mode);
	fcb->i_uid = cpu_to_le32(inode->i_uid);
	fcb->i_gid = cpu_to_le32(inode->i_gid);
	fcb->i_links_count = cpu_to_le16(inode->i_nlink);
	fcb->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
	fcb->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
	fcb->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
	oi->i_commit_size = i_size_read(inode);
	fcb->i_size = cpu_to_le64(oi->i_commit_size);
	fcb->i_generation = cpu_to_le32(inode->i_generation);

	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
		if (old_valid_dev(inode->i_rdev)) {
			fcb->i_data[0] =
				cpu_to_le32(old_encode_dev(inode->i_rdev));
			fcb->i_data[1] = 0;
		} else {
			fcb->i_data[0] = 0;
			fcb->i_data[1] =
				cpu_to_le32(new_encode_dev(inode->i_rdev));
			fcb->i_data[2] = 0;
		}
	} else
		memcpy(fcb->i_data, oi->i_data, sizeof(fcb->i_data));

1414
	ret = ore_get_io_state(&sbi->layout, &oi->oc, &ios);
1415
	if (unlikely(ret)) {
1416
		EXOFS_ERR("%s: ore_get_io_state failed.\n", __func__);
1417 1418 1419 1420 1421
		goto free_args;
	}

	attr = g_attr_inode_data;
	attr.val_ptr = fcb;
1422 1423
	ios->out_attr_len = 1;
	ios->out_attr = &attr;
1424

1425
	wait_obj_created(oi);
1426

1427
	if (!do_sync) {
1428
		args->sbi = sbi;
1429 1430 1431
		ios->done = updatei_done;
		ios->private = args;
	}
1432

1433
	ret = ore_write(ios);
1434
	if (!do_sync && !ret) {
1435 1436 1437 1438
		atomic_inc(&sbi->s_curr_pending);
		goto out; /* deallocation in updatei_done */
	}

1439
	ore_put_io_state(ios);
1440 1441 1442
free_args:
	kfree(args);
out:
B
Boaz Harrosh 已提交
1443 1444
	EXOFS_DBGMSG("(0x%lx) do_sync=%d ret=>%d\n",
		     inode->i_ino, do_sync, ret);
1445 1446 1447
	return ret;
}

1448
int exofs_write_inode(struct inode *inode, struct writeback_control *wbc)
1449
{
N
Nick Piggin 已提交
1450 1451
	/* FIXME: fix fsync and use wbc->sync_mode == WB_SYNC_ALL */
	return exofs_update_inode(inode, 1);
1452 1453 1454 1455 1456 1457
}

/*
 * Callback function from exofs_delete_inode() - don't have much cleaning up to
 * do.
 */
1458
static void delete_done(struct ore_io_state *ios, void *p)
1459
{
1460 1461
	struct exofs_sb_info *sbi = p;

1462
	ore_put_io_state(ios);
1463

1464 1465 1466 1467 1468 1469 1470 1471
	atomic_dec(&sbi->s_curr_pending);
}

/*
 * Called when the refcount of an inode reaches zero.  We remove the object
 * from the OSD here.  We make sure the object was created before we try and
 * delete it.
 */
A
Al Viro 已提交
1472
void exofs_evict_inode(struct inode *inode)
1473 1474 1475 1476
{
	struct exofs_i_info *oi = exofs_i(inode);
	struct super_block *sb = inode->i_sb;
	struct exofs_sb_info *sbi = sb->s_fs_info;
1477
	struct ore_io_state *ios;
1478 1479 1480 1481
	int ret;

	truncate_inode_pages(&inode->i_data, 0);

B
Boaz Harrosh 已提交
1482
	/* TODO: should do better here */
A
Al Viro 已提交
1483
	if (inode->i_nlink || is_bad_inode(inode))
1484 1485 1486
		goto no_delete;

	inode->i_size = 0;
1487
	clear_inode(inode);
1488

1489 1490 1491 1492 1493 1494
	/* if we are deleting an obj that hasn't been created yet, wait.
	 * This also makes sure that create_done cannot be called with an
	 * already evicted inode.
	 */
	wait_obj_created(oi);
	/* ignore the error, attempt a remove anyway */
B
Boaz Harrosh 已提交
1495 1496

	/* Now Remove the OSD objects */
1497
	ret = ore_get_io_state(&sbi->layout, &oi->oc, &ios);
B
Boaz Harrosh 已提交
1498
	if (unlikely(ret)) {
1499
		EXOFS_ERR("%s: ore_get_io_state failed\n", __func__);
B
Boaz Harrosh 已提交
1500
		return;
1501 1502
	}

1503 1504
	ios->done = delete_done;
	ios->private = sbi;
1505

1506
	ret = ore_remove(ios);
1507
	if (ret) {
1508 1509
		EXOFS_ERR("%s: ore_remove failed\n", __func__);
		ore_put_io_state(ios);
1510 1511 1512 1513 1514 1515 1516
		return;
	}
	atomic_inc(&sbi->s_curr_pending);

	return;

no_delete:
1517
	clear_inode(inode);
1518
}