inode.c 31.5 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 34 35
 * 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
 */

#include <linux/writeback.h>
#include <linux/buffer_head.h>
B
Boaz Harrosh 已提交
36
#include <scsi/scsi_device.h>
37 38 39

#include "exofs.h"

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

42 43 44 45
enum { BIO_MAX_PAGES_KMALLOC =
		(PAGE_SIZE - sizeof(struct bio)) / sizeof(struct bio_vec),
};

B
Boaz Harrosh 已提交
46 47 48 49 50
struct page_collect {
	struct exofs_sb_info *sbi;
	struct request_queue *req_q;
	struct inode *inode;
	unsigned expected_pages;
51
	struct exofs_io_state *ios;
B
Boaz Harrosh 已提交
52 53 54 55 56 57 58 59

	struct bio *bio;
	unsigned nr_pages;
	unsigned long length;
	loff_t pg_first; /* keep 64bit also in 32-arches */
};

static void _pcol_init(struct page_collect *pcol, unsigned expected_pages,
60
		       struct inode *inode)
B
Boaz Harrosh 已提交
61 62 63 64
{
	struct exofs_sb_info *sbi = inode->i_sb->s_fs_info;

	pcol->sbi = sbi;
B
Boaz Harrosh 已提交
65 66 67
	/* Create master bios on first Q, later on cloning, each clone will be
	 * allocated on it's destination Q
	 */
68
	pcol->req_q = osd_request_queue(sbi->layout.s_ods[0]);
B
Boaz Harrosh 已提交
69 70 71
	pcol->inode = inode;
	pcol->expected_pages = expected_pages;

72
	pcol->ios = NULL;
B
Boaz Harrosh 已提交
73 74 75 76 77 78 79 80 81 82 83 84 85 86
	pcol->bio = NULL;
	pcol->nr_pages = 0;
	pcol->length = 0;
	pcol->pg_first = -1;
}

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

	pcol->bio = NULL;
	pcol->nr_pages = 0;
	pcol->length = 0;
	pcol->pg_first = -1;
87
	pcol->ios = NULL;
B
Boaz Harrosh 已提交
88 89 90 91 92

	/* 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)
93
		pcol->expected_pages = BIO_MAX_PAGES_KMALLOC;
B
Boaz Harrosh 已提交
94 95 96 97
}

static int pcol_try_alloc(struct page_collect *pcol)
{
98 99 100 101
	int pages = min_t(unsigned, pcol->expected_pages,
			  BIO_MAX_PAGES_KMALLOC);

	if (!pcol->ios) { /* First time allocate io_state */
102
		int ret = exofs_get_io_state(&pcol->sbi->layout, &pcol->ios);
103 104 105 106

		if (ret)
			return ret;
	}
B
Boaz Harrosh 已提交
107 108

	for (; pages; pages >>= 1) {
109
		pcol->bio = bio_kmalloc(GFP_KERNEL, pages);
B
Boaz Harrosh 已提交
110 111 112 113
		if (likely(pcol->bio))
			return 0;
	}

114
	EXOFS_ERR("Failed to bio_kmalloc expected_pages=%u\n",
B
Boaz Harrosh 已提交
115 116 117 118 119 120
		  pcol->expected_pages);
	return -ENOMEM;
}

static void pcol_free(struct page_collect *pcol)
{
121 122 123 124 125 126 127 128 129
	if (pcol->bio) {
		bio_put(pcol->bio);
		pcol->bio = NULL;
	}

	if (pcol->ios) {
		exofs_put_io_state(pcol->ios);
		pcol->ios = NULL;
	}
B
Boaz Harrosh 已提交
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
}

static int pcol_add_page(struct page_collect *pcol, struct page *page,
			 unsigned len)
{
	int added_len = bio_add_pc_page(pcol->req_q, pcol->bio, page, len, 0);
	if (unlikely(len != added_len))
		return -ENOMEM;

	++pcol->nr_pages;
	pcol->length += len;
	return 0;
}

static int update_read_page(struct page *page, int ret)
{
	if (ret == 0) {
		/* Everything is OK */
		SetPageUptodate(page);
		if (PageError(page))
			ClearPageError(page);
	} else if (ret == -EFAULT) {
		/* 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);
		ret = 0; /* recovered error */
		EXOFS_DBGMSG("recovered read error\n");
	} else /* Error */
		SetPageError(page);

	return ret;
}

static void update_write_page(struct page *page, int ret)
{
	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.
 */
182
static int __readpages_done(struct page_collect *pcol, bool do_unlock)
B
Boaz Harrosh 已提交
183 184 185 186 187 188
{
	struct bio_vec *bvec;
	int i;
	u64 resid;
	u64 good_bytes;
	u64 length = 0;
189
	int ret = exofs_check_io(pcol->ios, &resid);
B
Boaz Harrosh 已提交
190 191 192 193 194 195

	if (likely(!ret))
		good_bytes = pcol->length;
	else
		good_bytes = pcol->length - resid;

B
Boaz Harrosh 已提交
196
	EXOFS_DBGMSG2("readpages_done(0x%lx) good_bytes=0x%llx"
B
Boaz Harrosh 已提交
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
		     " length=0x%lx nr_pages=%u\n",
		     pcol->inode->i_ino, _LLU(good_bytes), pcol->length,
		     pcol->nr_pages);

	__bio_for_each_segment(bvec, pcol->bio, i, 0) {
		struct page *page = bvec->bv_page;
		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 已提交
214
		EXOFS_DBGMSG2("    readpages_done(0x%lx, 0x%lx) %s\n",
B
Boaz Harrosh 已提交
215 216 217 218 219 220 221 222 223 224
			  inode->i_ino, page->index,
			  page_stat ? "bad_bytes" : "good_bytes");

		ret = update_read_page(page, page_stat);
		if (do_unlock)
			unlock_page(page);
		length += bvec->bv_len;
	}

	pcol_free(pcol);
B
Boaz Harrosh 已提交
225
	EXOFS_DBGMSG2("readpages_done END\n");
B
Boaz Harrosh 已提交
226 227 228 229
	return ret;
}

/* callback of async reads */
230
static void readpages_done(struct exofs_io_state *ios, void *p)
B
Boaz Harrosh 已提交
231 232 233
{
	struct page_collect *pcol = p;

234
	__readpages_done(pcol, true);
B
Boaz Harrosh 已提交
235
	atomic_dec(&pcol->sbi->s_curr_pending);
236
	kfree(pcol);
B
Boaz Harrosh 已提交
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
}

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

	__bio_for_each_segment(bvec, pcol->bio, i, 0) {
		struct page *page = bvec->bv_page;

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

		unlock_page(page);
	}
}

static int read_exec(struct page_collect *pcol, bool is_sync)
{
	struct exofs_i_info *oi = exofs_i(pcol->inode);
259
	struct exofs_io_state *ios = pcol->ios;
B
Boaz Harrosh 已提交
260 261 262 263 264 265 266 267 268
	struct page_collect *pcol_copy = NULL;
	int ret;

	if (!pcol->bio)
		return 0;

	/* see comment in _readpage() about sync reads */
	WARN_ON(is_sync && (pcol->nr_pages != 1));

269 270 271
	ios->bio = pcol->bio;
	ios->length = pcol->length;
	ios->offset = pcol->pg_first << PAGE_CACHE_SHIFT;
B
Boaz Harrosh 已提交
272 273

	if (is_sync) {
274 275
		exofs_oi_read(oi, pcol->ios);
		return __readpages_done(pcol, false);
B
Boaz Harrosh 已提交
276 277 278 279 280 281 282 283 284
	}

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

	*pcol_copy = *pcol;
285 286 287
	ios->done = readpages_done;
	ios->private = pcol_copy;
	ret = exofs_oi_read(oi, ios);
B
Boaz Harrosh 已提交
288 289 290 291 292
	if (unlikely(ret))
		goto err;

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

B
Boaz Harrosh 已提交
293
	EXOFS_DBGMSG2("read_exec obj=0x%llx start=0x%llx length=0x%lx\n",
294
		  ios->obj.id, _LLU(ios->offset), pcol->length);
B
Boaz Harrosh 已提交
295 296 297 298 299 300 301 302

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

err:
	if (!is_sync)
		_unlock_pcol_pages(pcol, ret, READ);
303 304

	pcol_free(pcol);
305

B
Boaz Harrosh 已提交
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
	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;

	/* FIXME: Just for debugging, will be removed */
	if (PageUptodate(page))
		EXOFS_ERR("PageUptodate(0x%lx, 0x%lx)\n", pcol->inode->i_ino,
			  page->index);

	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);

		unlock_page(page);
		EXOFS_DBGMSG("readpage_strip(0x%lx, 0x%lx) empty page,"
			     " splitting\n", inode->i_ino, page->index);

		return read_exec(pcol, false);
	}

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 = read_exec(pcol, false);
		if (unlikely(ret))
			goto fail;
		goto try_again;
	}

	if (!pcol->bio) {
		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 已提交
378
	EXOFS_DBGMSG2("    readpage_strip(0x%lx, 0x%lx) len=0x%zx\n",
B
Boaz Harrosh 已提交
379 380 381 382
		     inode->i_ino, page->index, len);

	ret = pcol_add_page(pcol, page, len);
	if (ret) {
B
Boaz Harrosh 已提交
383
		EXOFS_DBGMSG2("Failed pcol_add_page pages[i]=%p "
B
Boaz Harrosh 已提交
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
			  "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 */
		ret = read_exec(pcol, false);
		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;
	}

	return read_exec(&pcol, false);
}

static int _readpage(struct page *page, bool is_sync)
{
	struct page_collect pcol;
	int ret;

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

427 428
	/* readpage_strip might call read_exec(,is_sync==false) at several
	 * places but not if we have a single page.
B
Boaz Harrosh 已提交
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
	 */
	ret = readpage_strip(&pcol, page);
	if (ret) {
		EXOFS_ERR("_readpage => %d\n", ret);
		return ret;
	}

	return read_exec(&pcol, is_sync);
}

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

447 448
/* Callback for osd_write. All writes are asynchronous */
static void writepages_done(struct exofs_io_state *ios, void *p)
B
Boaz Harrosh 已提交
449 450 451 452 453 454 455
{
	struct page_collect *pcol = p;
	struct bio_vec *bvec;
	int i;
	u64 resid;
	u64  good_bytes;
	u64  length = 0;
456
	int ret = exofs_check_io(ios, &resid);
B
Boaz Harrosh 已提交
457 458 459 460 461 462 463 464

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

	if (likely(!ret))
		good_bytes = pcol->length;
	else
		good_bytes = pcol->length - resid;

B
Boaz Harrosh 已提交
465
	EXOFS_DBGMSG2("writepages_done(0x%lx) good_bytes=0x%llx"
B
Boaz Harrosh 已提交
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
		     " length=0x%lx nr_pages=%u\n",
		     pcol->inode->i_ino, _LLU(good_bytes), pcol->length,
		     pcol->nr_pages);

	__bio_for_each_segment(bvec, pcol->bio, i, 0) {
		struct page *page = bvec->bv_page;
		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 已提交
485
		EXOFS_DBGMSG2("    writepages_done(0x%lx, 0x%lx) status=%d\n",
B
Boaz Harrosh 已提交
486 487 488 489 490 491 492
			     inode->i_ino, page->index, page_stat);

		length += bvec->bv_len;
	}

	pcol_free(pcol);
	kfree(pcol);
B
Boaz Harrosh 已提交
493
	EXOFS_DBGMSG2("writepages_done END\n");
B
Boaz Harrosh 已提交
494 495 496 497 498
}

static int write_exec(struct page_collect *pcol)
{
	struct exofs_i_info *oi = exofs_i(pcol->inode);
499
	struct exofs_io_state *ios = pcol->ios;
B
Boaz Harrosh 已提交
500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
	struct page_collect *pcol_copy = NULL;
	int ret;

	if (!pcol->bio)
		return 0;

	pcol_copy = kmalloc(sizeof(*pcol_copy), GFP_KERNEL);
	if (!pcol_copy) {
		EXOFS_ERR("write_exec: Faild to kmalloc(pcol)\n");
		ret = -ENOMEM;
		goto err;
	}

	*pcol_copy = *pcol;

515
	pcol_copy->bio->bi_rw |= (1 << BIO_RW); /* FIXME: bio_set_dir() */
516 517 518 519 520 521 522 523

	ios->bio = pcol_copy->bio;
	ios->offset = pcol_copy->pg_first << PAGE_CACHE_SHIFT;
	ios->length = pcol_copy->length;
	ios->done = writepages_done;
	ios->private = pcol_copy;

	ret = exofs_oi_write(oi, ios);
B
Boaz Harrosh 已提交
524
	if (unlikely(ret)) {
525
		EXOFS_ERR("write_exec: exofs_oi_write() Faild\n");
B
Boaz Harrosh 已提交
526 527 528 529
		goto err;
	}

	atomic_inc(&pcol->sbi->s_curr_pending);
B
Boaz Harrosh 已提交
530
	EXOFS_DBGMSG2("write_exec(0x%lx, 0x%llx) start=0x%llx length=0x%lx\n",
531
		  pcol->inode->i_ino, pcol->pg_first, _LLU(ios->offset),
B
Boaz Harrosh 已提交
532 533 534 535 536 537 538
		  pcol->length);
	/* pages ownership was passed to pcol_copy */
	_pcol_reset(pcol);
	return 0;

err:
	_unlock_pcol_pages(pcol, ret, WRITE);
539
	pcol_free(pcol);
B
Boaz Harrosh 已提交
540
	kfree(pcol_copy);
541

B
Boaz Harrosh 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
	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);
585 586 587
			EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) "
				     "outside the limits\n",
				     inode->i_ino, page->index);
B
Boaz Harrosh 已提交
588 589 590 591 592 593 594 595 596 597 598 599 600 601
			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;
602 603 604

		EXOFS_DBGMSG("writepage_strip(0x%lx, 0x%lx) Discontinuity\n",
			     inode->i_ino, page->index);
B
Boaz Harrosh 已提交
605 606 607 608 609 610 611 612 613
		goto try_again;
	}

	if (!pcol->bio) {
		ret = pcol_try_alloc(pcol);
		if (unlikely(ret))
			goto fail;
	}

B
Boaz Harrosh 已提交
614
	EXOFS_DBGMSG2("    writepage_strip(0x%lx, 0x%lx) len=0x%zx\n",
B
Boaz Harrosh 已提交
615 616 617 618
		     inode->i_ino, page->index, len);

	ret = pcol_add_page(pcol, page, len);
	if (unlikely(ret)) {
B
Boaz Harrosh 已提交
619
		EXOFS_DBGMSG2("Failed pcol_add_page "
B
Boaz Harrosh 已提交
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
			     "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)) {
			EXOFS_DBGMSG("write_exec faild => %d", ret);
			goto fail;
		}

		goto try_again;
	}

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

	return 0;

fail:
639 640
	EXOFS_DBGMSG("Error: writepage_strip(0x%lx, 0x%lx)=>%d\n",
		     inode->i_ino, page->index, ret);
B
Boaz Harrosh 已提交
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
	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)
659
		expected_pages = end - start + 1;
B
Boaz Harrosh 已提交
660 661 662
	else
		expected_pages = mapping->nrpages;

663 664 665
	if (expected_pages < 32L)
		expected_pages = 32L;

B
Boaz Harrosh 已提交
666
	EXOFS_DBGMSG2("inode(0x%lx) wbc->start=0x%llx wbc->end=0x%llx "
667
		     "nrpages=%lu start=0x%lx end=0x%lx expected_pages=%ld\n",
B
Boaz Harrosh 已提交
668
		     mapping->host->i_ino, wbc->range_start, wbc->range_end,
669
		     mapping->nrpages, start, end, expected_pages);
B
Boaz Harrosh 已提交
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 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 728 729 730 731 732 733 734 735 736 737 738 739 740

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

	ret = write_cache_pages(mapping, wbc, writepage_strip, &pcol);
	if (ret) {
		EXOFS_ERR("write_cache_pages => %d\n", ret);
		return ret;
	}

	return write_exec(&pcol);
}

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);
}

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) {
			EXOFS_DBGMSG("simple_write_begin faild\n");
			return ret;
		}

		page = *pagep;
	}

	 /* read modify write */
	if (!PageUptodate(page) && (len != PAGE_CACHE_SIZE)) {
		ret = _readpage(page, true);
		if (ret) {
			/*SetPageError was done by _readpage. Is it ok?*/
			unlock_page(page);
			EXOFS_DBGMSG("__readpage_filler faild\n");
		}
	}

	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);
}

741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
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);
	if (i_size != inode->i_size)
		mark_inode_dirty(inode);
	return ret;
}

B
Boaz Harrosh 已提交
756 757 758 759 760 761
const struct address_space_operations exofs_aops = {
	.readpage	= exofs_readpage,
	.readpages	= exofs_readpages,
	.writepage	= exofs_writepage,
	.writepages	= exofs_writepages,
	.write_begin	= exofs_write_begin_export,
762
	.write_end	= exofs_write_end,
B
Boaz Harrosh 已提交
763 764
};

765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795
/******************************************************************************
 * 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);
}

/*
 * get_block_t - Fill in a buffer_head
 * An OSD takes care of block allocation so we just fake an allocation by
 * putting in the inode's sector_t in the buffer_head.
 * TODO: What about the case of create==0 and @iblock does not exist in the
 * object?
 */
static int exofs_get_block(struct inode *inode, sector_t iblock,
		    struct buffer_head *bh_result, int create)
{
	map_bh(bh_result, inode->i_sb, iblock);
	return 0;
}

const struct osd_attr g_attr_logical_length = ATTR_DEF(
	OSD_APAGE_OBJECT_INFORMATION, OSD_ATTR_OI_LOGICAL_LENGTH, 8);

796 797 798 799 800 801 802 803 804 805 806 807 808 809 810
static int _do_truncate(struct inode *inode)
{
	struct exofs_i_info *oi = exofs_i(inode);
	loff_t isize = i_size_read(inode);
	int ret;

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

	nobh_truncate_page(inode->i_mapping, isize, exofs_get_block);

	ret = exofs_oi_truncate(oi, (u64)isize);
	EXOFS_DBGMSG("(0x%lx) size=0x%llx\n", inode->i_ino, isize);
	return ret;
}

811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
/*
 * Truncate a file to the specified size - all we have to do is set the size
 * attribute.  We make sure the object exists first.
 */
void exofs_truncate(struct inode *inode)
{
	struct exofs_i_info *oi = exofs_i(inode);
	int ret;

	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode)
	     || S_ISLNK(inode->i_mode)))
		return;
	if (exofs_inode_is_fast_symlink(inode))
		return;
	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
		return;

	/* if we are about to truncate an object, and it hasn't been
	 * created yet, wait
	 */
	if (unlikely(wait_obj_created(oi)))
		goto fail;

834
	ret = _do_truncate(inode);
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
	if (ret)
		goto fail;

out:
	mark_inode_dirty(inode);
	return;
fail:
	make_bad_inode(inode);
	goto out;
}

/*
 * Set inode attributes - just call generic functions.
 */
int exofs_setattr(struct dentry *dentry, struct iattr *iattr)
{
	struct inode *inode = dentry->d_inode;
	int error;

	error = inode_change_ok(inode, iattr);
	if (error)
		return error;

	error = inode_setattr(inode, iattr);
	return error;
}
861 862 863

/*
 * Read an inode from the OSD, and return it as is.  We also return the size
864
 * attribute in the 'obj_size' argument.
865 866
 */
static int exofs_get_inode(struct super_block *sb, struct exofs_i_info *oi,
867
		    struct exofs_fcb *inode, uint64_t *obj_size)
868 869
{
	struct exofs_sb_info *sbi = sb->s_fs_info;
870 871
	struct osd_attr attrs[2];
	struct exofs_io_state *ios;
872 873
	int ret;

874
	*obj_size = ~0;
875
	ret = exofs_get_io_state(&sbi->layout, &ios);
876 877 878
	if (unlikely(ret)) {
		EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__);
		return ret;
879 880
	}

881 882 883
	ios->obj.id = exofs_oi_objno(oi);
	exofs_make_credential(oi->i_cred, &ios->obj);
	ios->cred = oi->i_cred;
884

885 886 887 888
	attrs[0] = g_attr_inode_data;
	attrs[1] = g_attr_logical_length;
	ios->in_attr = attrs;
	ios->in_attr_len = ARRAY_SIZE(attrs);
889

890
	ret = exofs_sbi_read(ios);
891 892 893
	if (ret)
		goto out;

894
	ret = extract_attr_from_ios(ios, &attrs[0]);
895
	if (ret) {
896
		EXOFS_ERR("%s: extract_attr of inode_data failed\n", __func__);
897 898
		goto out;
	}
899 900
	WARN_ON(attrs[0].len != EXOFS_INO_ATTR_SIZE);
	memcpy(inode, attrs[0].val_ptr, EXOFS_INO_ATTR_SIZE);
901

902
	ret = extract_attr_from_ios(ios, &attrs[1]);
903
	if (ret) {
904 905
		EXOFS_ERR("%s: extract_attr of logical_length failed\n",
			  __func__);
906 907
		goto out;
	}
908
	*obj_size = get_unaligned_be64(attrs[1].val_ptr);
909 910

out:
911
	exofs_put_io_state(ios);
912 913 914
	return ret;
}

915 916 917 918 919
static void __oi_init(struct exofs_i_info *oi)
{
	init_waitqueue_head(&oi->i_wq);
	oi->i_flags = 0;
}
920 921 922 923 924 925 926 927
/*
 * 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;
928
	uint64_t obj_size;
929 930 931 932 933 934 935 936
	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);
937
	__oi_init(oi);
938 939

	/* read the inode from the osd */
940
	ret = exofs_get_inode(sb, oi, &fcb, &obj_size);
941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960
	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);
	inode->i_nlink = le16_to_cpu(fcb.i_links_count);
	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);

961
	if ((inode->i_size != obj_size) &&
962
		(!exofs_inode_is_fast_symlink(inode))) {
B
Boaz Harrosh 已提交
963
		EXOFS_ERR("WARNING: Size of inode=%llu != object=%llu\n",
964 965
			  inode->i_size, _LLU(obj_size));
		/* FIXME: call exofs_inode_recovery() */
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
	}

	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));
	}

	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)) {
		BUG_ON(!obj_2bcreated(oi));
		wait_event(oi->i_wq, obj_created(oi));
	}
	return unlikely(is_bad_inode(&oi->vfs_inode)) ? -EIO : 0;
}
/*
 * 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.
 */
1032
static void create_done(struct exofs_io_state *ios, void *p)
1033 1034 1035 1036 1037 1038
{
	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;

1039 1040 1041
	ret = exofs_check_io(ios, NULL);
	exofs_put_io_state(ios);

1042 1043 1044 1045
	atomic_dec(&sbi->s_curr_pending);

	if (unlikely(ret)) {
		EXOFS_ERR("object=0x%llx creation faild in pid=0x%llx",
1046
			  _LLU(exofs_oi_objno(oi)), _LLU(sbi->layout.s_pid));
1047 1048 1049 1050 1051 1052 1053 1054 1055
		/*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);
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069

	atomic_dec(&inode->i_count);
	wake_up(&oi->i_wq);
}

/*
 * Set up a new inode and create an object for it on the OSD
 */
struct inode *exofs_new_inode(struct inode *dir, int mode)
{
	struct super_block *sb;
	struct inode *inode;
	struct exofs_i_info *oi;
	struct exofs_sb_info *sbi;
1070
	struct exofs_io_state *ios;
1071 1072 1073 1074 1075 1076 1077 1078
	int ret;

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

	oi = exofs_i(inode);
1079
	__oi_init(oi);
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106

	set_obj_2bcreated(oi);

	sbi = sb->s_fs_info;

	sb->s_dirt = 1;
	inode->i_uid = current->cred->fsuid;
	if (dir->i_mode & S_ISGID) {
		inode->i_gid = dir->i_gid;
		if (S_ISDIR(mode))
			mode |= S_ISGID;
	} else {
		inode->i_gid = current->cred->fsgid;
	}
	inode->i_mode = mode;

	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);

	mark_inode_dirty(inode);

1107
	ret = exofs_get_io_state(&sbi->layout, &ios);
1108 1109 1110
	if (unlikely(ret)) {
		EXOFS_ERR("exofs_new_inode: exofs_get_io_state failed\n");
		return ERR_PTR(ret);
1111 1112
	}

1113 1114
	ios->obj.id = exofs_oi_objno(oi);
	exofs_make_credential(oi->i_cred, &ios->obj);
1115 1116 1117 1118 1119 1120

	/* increment the refcount so that the inode will still be around when we
	 * reach the callback
	 */
	atomic_inc(&inode->i_count);

1121 1122 1123 1124
	ios->done = create_done;
	ios->private = inode;
	ios->cred = oi->i_cred;
	ret = exofs_sbi_create(ios);
1125 1126
	if (ret) {
		atomic_dec(&inode->i_count);
1127 1128
		exofs_put_io_state(ios);
		return ERR_PTR(ret);
1129 1130 1131 1132 1133
	}
	atomic_inc(&sbi->s_curr_pending);

	return inode;
}
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145

/*
 * 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().
 */
1146
static void updatei_done(struct exofs_io_state *ios, void *p)
1147 1148 1149
{
	struct updatei_args *args = p;

1150
	exofs_put_io_state(ios);
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165

	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;
1166
	struct exofs_io_state *ios;
1167 1168 1169 1170 1171 1172
	struct osd_attr attr;
	struct exofs_fcb *fcb;
	struct updatei_args *args;
	int ret;

	args = kzalloc(sizeof(*args), GFP_KERNEL);
B
Boaz Harrosh 已提交
1173 1174
	if (!args) {
		EXOFS_DBGMSG("Faild kzalloc of args\n");
1175
		return -ENOMEM;
B
Boaz Harrosh 已提交
1176
	}
1177 1178 1179 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

	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));

1205
	ret = exofs_get_io_state(&sbi->layout, &ios);
1206 1207
	if (unlikely(ret)) {
		EXOFS_ERR("%s: exofs_get_io_state failed.\n", __func__);
1208 1209 1210 1211 1212
		goto free_args;
	}

	attr = g_attr_inode_data;
	attr.val_ptr = fcb;
1213 1214
	ios->out_attr_len = 1;
	ios->out_attr = &attr;
1215 1216 1217 1218 1219 1220 1221 1222

	if (!obj_created(oi)) {
		EXOFS_DBGMSG("!obj_created\n");
		BUG_ON(!obj_2bcreated(oi));
		wait_event(oi->i_wq, obj_created(oi));
		EXOFS_DBGMSG("wait_event done\n");
	}

1223
	if (!do_sync) {
1224
		args->sbi = sbi;
1225 1226 1227
		ios->done = updatei_done;
		ios->private = args;
	}
1228

1229 1230
	ret = exofs_oi_write(oi, ios);
	if (!do_sync && !ret) {
1231 1232 1233 1234
		atomic_inc(&sbi->s_curr_pending);
		goto out; /* deallocation in updatei_done */
	}

1235
	exofs_put_io_state(ios);
1236 1237 1238
free_args:
	kfree(args);
out:
B
Boaz Harrosh 已提交
1239 1240
	EXOFS_DBGMSG("(0x%lx) do_sync=%d ret=>%d\n",
		     inode->i_ino, do_sync, ret);
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
	return ret;
}

int exofs_write_inode(struct inode *inode, int wait)
{
	return exofs_update_inode(inode, wait);
}

/*
 * Callback function from exofs_delete_inode() - don't have much cleaning up to
 * do.
 */
1253
static void delete_done(struct exofs_io_state *ios, void *p)
1254
{
1255 1256 1257 1258
	struct exofs_sb_info *sbi = p;

	exofs_put_io_state(ios);

1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
	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.
 */
void exofs_delete_inode(struct inode *inode)
{
	struct exofs_i_info *oi = exofs_i(inode);
	struct super_block *sb = inode->i_sb;
	struct exofs_sb_info *sbi = sb->s_fs_info;
1272
	struct exofs_io_state *ios;
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
	int ret;

	truncate_inode_pages(&inode->i_data, 0);

	if (is_bad_inode(inode))
		goto no_delete;

	mark_inode_dirty(inode);
	exofs_update_inode(inode, inode_needs_sync(inode));

	inode->i_size = 0;
	if (inode->i_blocks)
		exofs_truncate(inode);

	clear_inode(inode);

1289
	ret = exofs_get_io_state(&sbi->layout, &ios);
1290 1291
	if (unlikely(ret)) {
		EXOFS_ERR("%s: exofs_get_io_state failed\n", __func__);
1292 1293 1294 1295 1296 1297 1298 1299 1300
		return;
	}

	/* if we are deleting an obj that hasn't been created yet, wait */
	if (!obj_created(oi)) {
		BUG_ON(!obj_2bcreated(oi));
		wait_event(oi->i_wq, obj_created(oi));
	}

1301 1302 1303 1304 1305
	ios->obj.id = exofs_oi_objno(oi);
	ios->done = delete_done;
	ios->private = sbi;
	ios->cred = oi->i_cred;
	ret = exofs_sbi_remove(ios);
1306
	if (ret) {
1307 1308
		EXOFS_ERR("%s: exofs_sbi_remove failed\n", __func__);
		exofs_put_io_state(ios);
1309 1310 1311 1312 1313 1314 1315 1316 1317
		return;
	}
	atomic_inc(&sbi->s_curr_pending);

	return;

no_delete:
	clear_inode(inode);
}