X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fosd-ldiskfs%2Fosd_io.c;h=961e10dc42f47b24ba9a49df4bae3c7406fa7006;hb=83d660436a164758fd4a29c1433d11c0f4591196;hp=072e12c7826f1fa1e579d1e02a6d6e56029ae7d0;hpb=15f6148bea2baea8e199707645f968a7ddc50cc7;p=fs%2Flustre-release.git

diff --git a/lustre/osd-ldiskfs/osd_io.c b/lustre/osd-ldiskfs/osd_io.c
index 072e12c..961e10d 100644
--- a/lustre/osd-ldiskfs/osd_io.c
+++ b/lustre/osd-ldiskfs/osd_io.c
@@ -164,7 +164,6 @@ static void dio_complete_routine(struct bio *bio, int error)
 {
 #endif
 	struct osd_iobuf *iobuf = bio->bi_private;
-	int iter;
 	struct bio_vec *bvl;
 
         /* CAVEAT EMPTOR: possibly in IRQ context
@@ -191,7 +190,9 @@ static void dio_complete_routine(struct bio *bio, int error)
 
 	/* the check is outside of the cycle for performance reason -bzzz */
 	if (!bio_data_dir(bio)) {
-		bio_for_each_segment_all(bvl, bio, iter) {
+		DECLARE_BVEC_ITER_ALL(iter_all);
+
+		bio_for_each_segment_all(bvl, bio, iter_all) {
 			if (likely(error == 0))
 				SetPageUptodate(bvl_to_page(bvl));
 			LASSERT(PageLocked(bvl_to_page(bvl)));
@@ -279,11 +280,11 @@ static int can_be_merged(struct bio *bio, sector_t sector)
 static void bio_integrity_fault_inject(struct bio *bio)
 {
 	struct bio_vec *bvec;
-	int i;
+	DECLARE_BVEC_ITER_ALL(iter_all);
 	void *kaddr;
 	char *addr;
 
-	bio_for_each_segment_all(bvec, bio, i) {
+	bio_for_each_segment_all(bvec, bio, iter_all) {
 		struct page *page = bvec->bv_page;
 
 		kaddr = kmap(page);
@@ -329,12 +330,13 @@ static int osd_bio_integrity_compare(struct bio *bio, struct block_device *bdev,
 		bip->bip_vec->bv_offset;
 	struct bio_vec *bv;
 	sector_t sector = bio_start_sector(bio);
-	unsigned int i, sectors, total;
+	unsigned int sectors, total;
+	DECLARE_BVEC_ITER_ALL(iter_all);
 	__u16 *expected_guard;
 	int rc;
 
 	total = 0;
-	bio_for_each_segment_all(bv, bio, i) {
+	bio_for_each_segment_all(bv, bio, iter_all) {
 		lnb = iobuf->dr_lnbs[index];
 		expected_guard = lnb->lnb_guards;
 		sectors = bv->bv_len / sector_size;
@@ -468,7 +470,7 @@ static int osd_do_bio(struct osd_device *osd, struct inode *inode,
 	int rc = 0;
 	bool fault_inject;
 	bool integrity_enabled;
-	DECLARE_PLUG(plug);
+	struct blk_plug plug;
 	ENTRY;
 
 	fault_inject = OBD_FAIL_CHECK(OBD_FAIL_OST_INTEGRITY_FAULT);
@@ -522,14 +524,13 @@ static int osd_do_bio(struct osd_device *osd, struct inode *inode,
 				unsigned int bi_size = bio_sectors(bio) << 9;
 
 				/* Dang! I have to fragment this I/O */
-				CDEBUG(D_INODE, "bio++ sz %d vcnt %d(%d) "
-				       "sectors %d(%d) psg %d(%d) hsg %d(%d)\n",
+				CDEBUG(D_INODE,
+				       "bio++ sz %d vcnt %d(%d) sectors %d(%d) psg %d(%d)\n",
 				       bi_size, bio->bi_vcnt, bio->bi_max_vecs,
 				       bio_sectors(bio),
 				       queue_max_sectors(q),
-				       bio->bi_phys_segments,
-				       queue_max_phys_segments(q),
-				       0, queue_max_hw_segments(q));
+				       osd_bio_nr_segs(bio),
+				       queue_max_segments(q));
 				rc = osd_bio_integrity_handle(osd, bio,
 					iobuf, bio_start_page_idx,
 					fault_inject, integrity_enabled);
@@ -610,8 +611,9 @@ out:
 }
 
 static int osd_map_remote_to_local(loff_t offset, ssize_t len, int *nrpages,
-                                   struct niobuf_local *lnb)
+				   struct niobuf_local *lnb, int maxlnb)
 {
+	int rc = 0;
         ENTRY;
 
         *nrpages = 0;
@@ -620,6 +622,11 @@ static int osd_map_remote_to_local(loff_t offset, ssize_t len, int *nrpages,
 		int poff = offset & (PAGE_SIZE - 1);
 		int plen = PAGE_SIZE - poff;
 
+		if (*nrpages >= maxlnb) {
+			rc = -EOVERFLOW;
+			break;
+		}
+
                 if (plen > len)
                         plen = len;
 		lnb->lnb_file_offset = offset;
@@ -631,6 +638,7 @@ static int osd_map_remote_to_local(loff_t offset, ssize_t len, int *nrpages,
 		lnb->lnb_rc = 0;
 		lnb->lnb_guard_rpc = 0;
 		lnb->lnb_guard_disk = 0;
+		lnb->lnb_locked = 0;
 
                 LASSERTF(plen <= len, "plen %u, len %lld\n", plen,
                          (long long) len);
@@ -640,56 +648,62 @@ static int osd_map_remote_to_local(loff_t offset, ssize_t len, int *nrpages,
                 (*nrpages)++;
         }
 
-        RETURN(0);
+	RETURN(rc);
 }
 
 static struct page *osd_get_page(const struct lu_env *env, struct dt_object *dt,
-				 loff_t offset, gfp_t gfp_mask)
+				 loff_t offset, gfp_t gfp_mask, bool cache)
 {
 	struct osd_thread_info *oti = osd_oti_get(env);
 	struct inode *inode = osd_dt_obj(dt)->oo_inode;
 	struct osd_device *d = osd_obj2dev(osd_dt_obj(dt));
 	struct page *page;
-	int cur = oti->oti_dio_pages_used;
+	int cur;
 
         LASSERT(inode);
 
-	if (osd_use_page_cache(d)) {
+	if (cache) {
 		page = find_or_create_page(inode->i_mapping,
-					   offset >> PAGE_SHIFT,
-					   gfp_mask);
+					   offset >> PAGE_SHIFT, gfp_mask);
 
-		if (likely(page))
-			LASSERT(!test_bit(PG_private_2, &page->flags));
-		else
+		if (likely(page)) {
+			LASSERT(!PagePrivate2(page));
+			wait_on_page_writeback(page);
+		} else {
 			lprocfs_counter_add(d->od_stats, LPROC_OSD_NO_PAGE, 1);
-	} else {
+		}
 
-		LASSERT(oti->oti_dio_pages);
+		return page;
+	}
 
-		if (unlikely(!oti->oti_dio_pages[cur])) {
-			LASSERT(cur < PTLRPC_MAX_BRW_PAGES);
-			page = alloc_page(gfp_mask);
-			if (!page)
-				return NULL;
-			oti->oti_dio_pages[cur] = page;
+	if (inode->i_mapping->nrpages) {
+		/* consult with pagecache, but do not create new pages */
+		/* this is normally used once */
+		page = find_lock_page(inode->i_mapping, offset >> PAGE_SHIFT);
+		if (page) {
+			wait_on_page_writeback(page);
+			return page;
 		}
+	}
 
-		page = oti->oti_dio_pages[cur];
-		LASSERT(!test_bit(PG_private_2, &page->flags));
-		set_bit(PG_private_2, &page->flags);
-		oti->oti_dio_pages_used++;
-
-		LASSERT(!PageLocked(page));
+	LASSERT(oti->oti_dio_pages);
+	cur = oti->oti_dio_pages_used;
+	page = oti->oti_dio_pages[cur];
+
+	if (unlikely(!page)) {
+		LASSERT(cur < PTLRPC_MAX_BRW_PAGES);
+		page = alloc_page(gfp_mask);
+		if (!page)
+			return NULL;
+		oti->oti_dio_pages[cur] = page;
+		SetPagePrivate2(page);
 		lock_page(page);
-
-		LASSERT(!page->mapping);
-		LASSERT(!PageWriteback(page));
-		ClearPageUptodate(page);
-
-		page->index = offset >> PAGE_SHIFT;
 	}
 
+	ClearPageUptodate(page);
+	page->index = offset >> PAGE_SHIFT;
+	oti->oti_dio_pages_used++;
+
 	return page;
 }
 
@@ -738,21 +752,17 @@ static int osd_bufs_put(const struct lu_env *env, struct dt_object *dt,
 
 		if (page == NULL)
 			continue;
-		LASSERT(PageLocked(page));
 
 		/* if the page isn't cached, then reset uptodate
 		 * to prevent reuse */
-		if (test_bit(PG_private_2, &page->flags)) {
-			clear_bit(PG_private_2, &page->flags);
-			ClearPageUptodate(page);
-			unlock_page(page);
+		if (PagePrivate2(page)) {
 			oti->oti_dio_pages_used--;
 		} else {
-			unlock_page(page);
+			if (lnb[i].lnb_locked)
+				unlock_page(page);
 			if (pagevec_add(&pvec, page) == 0)
 				pagevec_release(&pvec);
 		}
-		dt_object_put(env, dt);
 
 		lnb[i].lnb_page = NULL;
 	}
@@ -791,40 +801,89 @@ static int osd_bufs_put(const struct lu_env *env, struct dt_object *dt,
  */
 static int osd_bufs_get(const struct lu_env *env, struct dt_object *dt,
 			loff_t pos, ssize_t len, struct niobuf_local *lnb,
-			enum dt_bufs_type rw)
+			int maxlnb, enum dt_bufs_type rw)
 {
 	struct osd_thread_info *oti = osd_oti_get(env);
 	struct osd_object *obj = osd_dt_obj(dt);
-	int npages, i, rc = 0;
+	struct osd_device *osd   = osd_obj2dev(obj);
+	int npages, i, iosize, rc = 0;
+	bool cache, write;
+	loff_t fsize;
 	gfp_t gfp_mask;
 
 	LASSERT(obj->oo_inode);
 
-	if (!osd_use_page_cache(osd_obj2dev(obj))) {
-		if (unlikely(!oti->oti_dio_pages)) {
-			OBD_ALLOC(oti->oti_dio_pages,
-				  sizeof(struct page *) * PTLRPC_MAX_BRW_PAGES);
-			if (!oti->oti_dio_pages)
-				return -ENOMEM;
+	rc = osd_map_remote_to_local(pos, len, &npages, lnb, maxlnb);
+	if (rc)
+		RETURN(rc);
+
+	write = rw & DT_BUFS_TYPE_WRITE;
+
+	fsize = lnb[npages - 1].lnb_file_offset + lnb[npages - 1].lnb_len;
+	iosize = fsize - lnb[0].lnb_file_offset;
+	fsize = max(fsize, i_size_read(obj->oo_inode));
+
+	cache = rw & DT_BUFS_TYPE_READAHEAD;
+	if (cache)
+		goto bypass_checks;
+
+	cache = osd_use_page_cache(osd);
+	while (cache) {
+		if (write) {
+			if (!osd->od_writethrough_cache) {
+				cache = false;
+				break;
+			}
+			if (iosize > osd->od_writethrough_max_iosize) {
+				cache = false;
+				break;
+			}
+		} else {
+			if (!osd->od_read_cache) {
+				cache = false;
+				break;
+			}
+			if (iosize > osd->od_readcache_max_iosize) {
+				cache = false;
+				break;
+			}
 		}
+		/* don't use cache on large files */
+		if (osd->od_readcache_max_filesize &&
+		    fsize > osd->od_readcache_max_filesize)
+			cache = false;
+		break;
 	}
 
-	osd_map_remote_to_local(pos, len, &npages, lnb);
+bypass_checks:
+	if (!cache && unlikely(!oti->oti_dio_pages)) {
+		OBD_ALLOC_PTR_ARRAY(oti->oti_dio_pages, PTLRPC_MAX_BRW_PAGES);
+		if (!oti->oti_dio_pages)
+			return -ENOMEM;
+	}
 
 	/* this could also try less hard for DT_BUFS_TYPE_READAHEAD pages */
 	gfp_mask = rw & DT_BUFS_TYPE_LOCAL ? (GFP_NOFS | __GFP_HIGHMEM) :
 					     GFP_HIGHUSER;
 	for (i = 0; i < npages; i++, lnb++) {
 		lnb->lnb_page = osd_get_page(env, dt, lnb->lnb_file_offset,
-					     gfp_mask);
+					     gfp_mask, cache);
 		if (lnb->lnb_page == NULL)
 			GOTO(cleanup, rc = -ENOMEM);
 
-		wait_on_page_writeback(lnb->lnb_page);
-		BUG_ON(PageWriteback(lnb->lnb_page));
+		lnb->lnb_locked = 1;
+	}
 
-		lu_object_get(&dt->do_lu);
+#if 0
+	/* XXX: this version doesn't invalidate cached pages, but use them */
+	if (!cache && write && obj->oo_inode->i_mapping->nrpages) {
+		/* do not allow data aliasing, invalidate pagecache */
+		/* XXX: can be quite expensive in mixed case */
+		invalidate_mapping_pages(obj->oo_inode->i_mapping,
+				lnb[0].lnb_file_offset >> PAGE_SHIFT,
+				lnb[npages - 1].lnb_file_offset >> PAGE_SHIFT);
 	}
+#endif
 
 	RETURN(i);
 
@@ -834,348 +893,6 @@ cleanup:
 	return rc;
 }
 
-#ifndef HAVE_LDISKFS_MAP_BLOCKS
-
-#ifdef HAVE_EXT_PBLOCK /* Name changed to ext4_ext_pblock for kernel 2.6.35 */
-#define ldiskfs_ext_pblock(ex) ext_pblock((ex))
-#endif
-
-struct bpointers {
-	sector_t *blocks;
-	unsigned long start;
-	int num;
-	int init_num;
-	int create;
-};
-
-static long ldiskfs_ext_find_goal(struct inode *inode,
-				  struct ldiskfs_ext_path *path,
-				  unsigned long block, int *aflags)
-{
-	struct ldiskfs_inode_info *ei = LDISKFS_I(inode);
-	unsigned long bg_start;
-	unsigned long colour;
-	int depth;
-
-	if (path) {
-		struct ldiskfs_extent *ex;
-		depth = path->p_depth;
-
-		/* try to predict block placement */
-		if ((ex = path[depth].p_ext))
-			return ldiskfs_ext_pblock(ex) +
-				(block - le32_to_cpu(ex->ee_block));
-
-		/* it looks index is empty
-		 * try to find starting from index itself */
-		if (path[depth].p_bh)
-			return path[depth].p_bh->b_blocknr;
-	}
-
-	/* OK. use inode's group */
-	bg_start = (ei->i_block_group * LDISKFS_BLOCKS_PER_GROUP(inode->i_sb)) +
-		le32_to_cpu(LDISKFS_SB(inode->i_sb)->s_es->s_first_data_block);
-	colour = (current->pid % 16) *
-		(LDISKFS_BLOCKS_PER_GROUP(inode->i_sb) / 16);
-	return bg_start + colour + block;
-}
-
-static unsigned long new_blocks(handle_t *handle, struct inode *inode,
-				struct ldiskfs_ext_path *path,
-				unsigned long block, unsigned long *count,
-				int *err)
-{
-	struct ldiskfs_allocation_request ar;
-	unsigned long pblock;
-	int aflags;
-
-	/* find neighbour allocated blocks */
-	ar.lleft = block;
-	*err = ldiskfs_ext_search_left(inode, path, &ar.lleft, &ar.pleft);
-	if (*err)
-		return 0;
-	ar.lright = block;
-	*err = ldiskfs_ext_search_right(inode, path, &ar.lright, &ar.pright);
-	if (*err)
-		return 0;
-
-	/* allocate new block */
-	ar.goal = ldiskfs_ext_find_goal(inode, path, block, &aflags);
-	ar.inode = inode;
-	ar.logical = block;
-	ar.len = *count;
-	ar.flags = LDISKFS_MB_HINT_DATA;
-	pblock = ldiskfs_mb_new_blocks(handle, &ar, err);
-	*count = ar.len;
-	return pblock;
-}
-
-static int ldiskfs_ext_new_extent_cb(struct inode *inode,
-				     struct ldiskfs_ext_path *path,
-				     struct ldiskfs_ext_cache *cex,
-#ifdef HAVE_EXT_PREPARE_CB_EXTENT
-				     struct ldiskfs_extent *ex,
-#endif
-				     void *cbdata)
-{
-	struct bpointers *bp = cbdata;
-	struct ldiskfs_extent nex;
-	unsigned long pblock = 0;
-	unsigned long tgen;
-	int err, i;
-	unsigned long count;
-	handle_t *handle;
-
-#ifdef LDISKFS_EXT_CACHE_EXTENT /* until kernel 2.6.37 */
-	if (cex->ec_type == LDISKFS_EXT_CACHE_EXTENT) {
-#else
-	if ((cex->ec_len != 0) && (cex->ec_start != 0)) {
-#endif
-		err = EXT_CONTINUE;
-		goto map;
-	}
-
-	if (bp->create == 0) {
-		i = 0;
-		if (cex->ec_block < bp->start)
-			i = bp->start - cex->ec_block;
-		if (i >= cex->ec_len)
-			CERROR("nothing to do?! i = %d, e_num = %u\n",
-					i, cex->ec_len);
-		for (; i < cex->ec_len && bp->num; i++) {
-			*(bp->blocks) = 0;
-			bp->blocks++;
-			bp->num--;
-			bp->start++;
-		}
-
-		return EXT_CONTINUE;
-	}
-
-	tgen = LDISKFS_I(inode)->i_ext_generation;
-	count = ldiskfs_ext_calc_credits_for_insert(inode, path);
-
-	handle = osd_journal_start(inode, LDISKFS_HT_MISC,
-				   count + LDISKFS_ALLOC_NEEDED + 1);
-	if (IS_ERR(handle)) {
-		return PTR_ERR(handle);
-	}
-
-	if (tgen != LDISKFS_I(inode)->i_ext_generation) {
-		/* the tree has changed. so path can be invalid at moment */
-		ldiskfs_journal_stop(handle);
-		return EXT_REPEAT;
-	}
-
-	/* In 2.6.32 kernel, ldiskfs_ext_walk_space()'s callback func is not
-	 * protected by i_data_sem as whole. so we patch it to store
-	 * generation to path and now verify the tree hasn't changed */
-	down_write((&LDISKFS_I(inode)->i_data_sem));
-
-	/* validate extent, make sure the extent tree does not changed */
-	if (LDISKFS_I(inode)->i_ext_generation != path[0].p_generation) {
-		/* cex is invalid, try again */
-		up_write(&LDISKFS_I(inode)->i_data_sem);
-		ldiskfs_journal_stop(handle);
-		return EXT_REPEAT;
-	}
-
-	count = cex->ec_len;
-	pblock = new_blocks(handle, inode, path, cex->ec_block, &count, &err);
-	if (!pblock)
-		goto out;
-	BUG_ON(count > cex->ec_len);
-
-	/* insert new extent */
-	nex.ee_block = cpu_to_le32(cex->ec_block);
-	ldiskfs_ext_store_pblock(&nex, pblock);
-	nex.ee_len = cpu_to_le16(count);
-	err = ldiskfs_ext_insert_extent(handle, inode, path, &nex, 0);
-	if (err) {
-		/* free data blocks we just allocated */
-		/* not a good idea to call discard here directly,
-		 * but otherwise we'd need to call it every free() */
-		ldiskfs_discard_preallocations(inode);
-#ifdef HAVE_EXT_FREE_BLOCK_WITH_BUFFER_HEAD /* Introduced in 2.6.32-rc7 */
-		ldiskfs_free_blocks(handle, inode, NULL,
-				    ldiskfs_ext_pblock(&nex),
-				    le16_to_cpu(nex.ee_len), 0);
-#else
-		ldiskfs_free_blocks(handle, inode, ldiskfs_ext_pblock(&nex),
-				    le16_to_cpu(nex.ee_len), 0);
-#endif
-		goto out;
-	}
-
-	/*
-	 * Putting len of the actual extent we just inserted,
-	 * we are asking ldiskfs_ext_walk_space() to continue
-	 * scaning after that block
-	 */
-	cex->ec_len = le16_to_cpu(nex.ee_len);
-	cex->ec_start = ldiskfs_ext_pblock(&nex);
-	BUG_ON(le16_to_cpu(nex.ee_len) == 0);
-	BUG_ON(le32_to_cpu(nex.ee_block) != cex->ec_block);
-
-out:
-	up_write((&LDISKFS_I(inode)->i_data_sem));
-	ldiskfs_journal_stop(handle);
-map:
-	if (err >= 0) {
-		/* map blocks */
-		if (bp->num == 0) {
-			CERROR("hmm. why do we find this extent?\n");
-			CERROR("initial space: %lu:%u\n",
-				bp->start, bp->init_num);
-#ifdef LDISKFS_EXT_CACHE_EXTENT /* until kernel 2.6.37 */
-			CERROR("current extent: %u/%u/%llu %d\n",
-				cex->ec_block, cex->ec_len,
-				(unsigned long long)cex->ec_start,
-				cex->ec_type);
-#else
-			CERROR("current extent: %u/%u/%llu\n",
-				cex->ec_block, cex->ec_len,
-				(unsigned long long)cex->ec_start);
-#endif
-		}
-		i = 0;
-		if (cex->ec_block < bp->start)
-			i = bp->start - cex->ec_block;
-		if (i >= cex->ec_len)
-			CERROR("nothing to do?! i = %d, e_num = %u\n",
-					i, cex->ec_len);
-		for (; i < cex->ec_len && bp->num; i++) {
-			*(bp->blocks) = cex->ec_start + i;
-			/* unmap any underlying metadata from
-			 * the block device mapping.  b=6998.
-			 */
-			if (pblock != 0)
-				clean_bdev_aliases(inode->i_sb->s_bdev,
-						   *(bp->blocks), 1);
-			bp->blocks++;
-			bp->num--;
-			bp->start++;
-		}
-	}
-	return err;
-}
-
-static int osd_ldiskfs_map_nblocks(struct inode *inode, unsigned long index,
-				   int clen, sector_t *blocks, int create)
-{
-	int blocks_per_page = PAGE_SIZE >> inode->i_blkbits;
-	struct bpointers bp;
-	int err;
-
-	if (index + clen >= inode->i_sb->s_maxbytes >> PAGE_SHIFT)
-		return -EFBIG;
-
-	bp.blocks = blocks;
-	bp.start = index * blocks_per_page;
-	bp.init_num = bp.num = clen * blocks_per_page;
-	bp.create = create;
-
-	CDEBUG(D_OTHER, "blocks %lu-%lu requested for inode %u\n",
-	       bp.start, bp.start + bp.num - 1, (unsigned)inode->i_ino);
-
-	err = ldiskfs_ext_walk_space(inode, bp.start, bp.num,
-				     ldiskfs_ext_new_extent_cb, &bp);
-	ldiskfs_ext_invalidate_cache(inode);
-
-	return err;
-}
-
-static int osd_ldiskfs_map_bm_inode_pages(struct inode *inode,
-					  struct page **page, int pages,
-					  sector_t *blocks, int create)
-{
-	int blocks_per_page = PAGE_SIZE >> inode->i_blkbits;
-	pgoff_t bitmap_max_page_index;
-	sector_t *b;
-	int rc = 0, i;
-
-	bitmap_max_page_index = LDISKFS_SB(inode->i_sb)->s_bitmap_maxbytes >>
-				PAGE_SHIFT;
-	for (i = 0, b = blocks; i < pages; i++, page++) {
-		if ((*page)->index + 1 >= bitmap_max_page_index) {
-			rc = -EFBIG;
-			break;
-		}
-		rc = ldiskfs_map_inode_page(inode, *page, b, create);
-		if (rc) {
-			CERROR("ino %lu, blk %llu create %d: rc %d\n",
-			       inode->i_ino,
-			       (unsigned long long)*b, create, rc);
-			break;
-		}
-		b += blocks_per_page;
-	}
-	return rc;
-}
-
-static int osd_ldiskfs_map_ext_inode_pages(struct inode *inode,
-					   struct page **page,
-					   int pages, sector_t *blocks,
-					   int create)
-{
-	int rc = 0, i = 0, clen = 0;
-	struct page *fp = NULL;
-
-	CDEBUG(D_OTHER, "inode %lu: map %d pages from %lu\n",
-		inode->i_ino, pages, (*page)->index);
-
-	/* pages are sorted already. so, we just have to find
-	 * contig. space and process them properly */
-	while (i < pages) {
-		if (fp == NULL) {
-			/* start new extent */
-			fp = *page++;
-			clen = 1;
-			i++;
-			continue;
-		} else if (fp->index + clen == (*page)->index) {
-			/* continue the extent */
-			page++;
-			clen++;
-			i++;
-			continue;
-		}
-
-		/* process found extent */
-		rc = osd_ldiskfs_map_nblocks(inode, fp->index, clen,
-					     blocks, create);
-		if (rc)
-			GOTO(cleanup, rc);
-
-		/* look for next extent */
-		fp = NULL;
-		blocks += clen * (PAGE_SIZE >> inode->i_blkbits);
-	}
-
-	if (fp)
-		rc = osd_ldiskfs_map_nblocks(inode, fp->index, clen,
-					     blocks, create);
-
-cleanup:
-	return rc;
-}
-
-static int osd_ldiskfs_map_inode_pages(struct inode *inode, struct page **page,
-				       int pages, sector_t *blocks,
-				       int create)
-{
-	int rc;
-
-	if (LDISKFS_I(inode)->i_flags & LDISKFS_EXTENTS_FL) {
-		rc = osd_ldiskfs_map_ext_inode_pages(inode, page, pages,
-						     blocks, create);
-		return rc;
-	}
-	rc = osd_ldiskfs_map_bm_inode_pages(inode, page, pages, blocks, create);
-
-	return rc;
-}
-#else
 static int osd_ldiskfs_map_inode_pages(struct inode *inode, struct page **page,
 				       int pages, sector_t *blocks,
 				       int create)
@@ -1261,7 +978,6 @@ cont_map:
 cleanup:
 	return rc;
 }
-#endif /* HAVE_LDISKFS_MAP_BLOCKS */
 
 static int osd_write_prep(const struct lu_env *env, struct dt_object *dt,
                           struct niobuf_local *lnb, int npages)
@@ -1270,14 +986,11 @@ static int osd_write_prep(const struct lu_env *env, struct dt_object *dt,
         struct osd_iobuf       *iobuf = &oti->oti_iobuf;
         struct inode           *inode = osd_dt_obj(dt)->oo_inode;
         struct osd_device      *osd   = osd_obj2dev(osd_dt_obj(dt));
-	ktime_t start;
-	ktime_t end;
+	ktime_t start, end;
 	s64 timediff;
-        ssize_t                 isize;
-        __s64                   maxidx;
-        int                     rc = 0;
-        int                     i;
-        int                     cache = 0;
+	ssize_t isize;
+	__s64  maxidx;
+	int i, rc = 0;
 
         LASSERT(inode);
 
@@ -1288,18 +1001,9 @@ static int osd_write_prep(const struct lu_env *env, struct dt_object *dt,
 	isize = i_size_read(inode);
 	maxidx = ((isize + PAGE_SIZE - 1) >> PAGE_SHIFT) - 1;
 
-        if (osd->od_writethrough_cache)
-                cache = 1;
-        if (isize > osd->od_readcache_max_filesize)
-                cache = 0;
-
 	start = ktime_get();
 	for (i = 0; i < npages; i++) {
 
-		if (cache == 0)
-			generic_error_remove_page(inode->i_mapping,
-						  lnb[i].lnb_page);
-
 		/*
 		 * till commit the content of the page is undefined
 		 * we'll set it uptodate once bulk is done. otherwise
@@ -1409,20 +1113,20 @@ static int osd_declare_write_commit(const struct lu_env *env,
 	int			i;
 	int			newblocks;
 	int			rc = 0;
-	int			flags = 0;
 	int			credits = 0;
 	long long		quota_space = 0;
 	struct osd_fextent	extent = { 0 };
+	enum osd_quota_local_flags local_flags = 0;
 	enum osd_qid_declare_flags declare_flags = OSD_QID_BLK;
 	ENTRY;
 
-        LASSERT(handle != NULL);
-        oh = container_of0(handle, struct osd_thandle, ot_super);
-        LASSERT(oh->ot_handle == NULL);
+	LASSERT(handle != NULL);
+	oh = container_of(handle, struct osd_thandle, ot_super);
+	LASSERT(oh->ot_handle == NULL);
 
-        newblocks = npages;
+	newblocks = npages;
 
-        /* calculate number of extents (probably better to pass nb) */
+	/* calculate number of extents (probably better to pass nb) */
 	for (i = 0; i < npages; i++) {
 		if (i && lnb[i].lnb_file_offset !=
 		    lnb[i - 1].lnb_file_offset + lnb[i - 1].lnb_len)
@@ -1497,16 +1201,16 @@ static int osd_declare_write_commit(const struct lu_env *env,
 
 	rc = osd_declare_inode_qid(env, i_uid_read(inode), i_gid_read(inode),
 				   i_projid_read(inode), quota_space, oh,
-				   osd_dt_obj(dt), &flags, declare_flags);
+				   osd_dt_obj(dt), &local_flags, declare_flags);
 
 	/* we need only to store the overquota flags in the first lnb for
 	 * now, once we support multiple objects BRW, this code needs be
 	 * revised. */
-	if (flags & QUOTA_FL_OVER_USRQUOTA)
+	if (local_flags & QUOTA_FL_OVER_USRQUOTA)
 		lnb[0].lnb_flags |= OBD_BRW_OVER_USRQUOTA;
-	if (flags & QUOTA_FL_OVER_GRPQUOTA)
+	if (local_flags & QUOTA_FL_OVER_GRPQUOTA)
 		lnb[0].lnb_flags |= OBD_BRW_OVER_GRPQUOTA;
-	if (flags & QUOTA_FL_OVER_PRJQUOTA)
+	if (local_flags & QUOTA_FL_OVER_PRJQUOTA)
 		lnb[0].lnb_flags |= OBD_BRW_OVER_PRJQUOTA;
 
 	if (rc == 0)
@@ -1517,26 +1221,31 @@ static int osd_declare_write_commit(const struct lu_env *env,
 
 /* Check if a block is allocated or not */
 static int osd_write_commit(const struct lu_env *env, struct dt_object *dt,
-                            struct niobuf_local *lnb, int npages,
-                            struct thandle *thandle)
+			    struct niobuf_local *lnb, int npages,
+			    struct thandle *thandle, __u64 user_size)
 {
-        struct osd_thread_info *oti = osd_oti_get(env);
-        struct osd_iobuf *iobuf = &oti->oti_iobuf;
-        struct inode *inode = osd_dt_obj(dt)->oo_inode;
-        struct osd_device  *osd = osd_obj2dev(osd_dt_obj(dt));
-        loff_t isize;
-        int rc = 0, i;
+	struct osd_thread_info *oti = osd_oti_get(env);
+	struct osd_iobuf *iobuf = &oti->oti_iobuf;
+	struct inode *inode = osd_dt_obj(dt)->oo_inode;
+	struct osd_device  *osd = osd_obj2dev(osd_dt_obj(dt));
+	loff_t disk_size;
+	int rc = 0, i;
 
-        LASSERT(inode);
+	LASSERT(inode);
 
 	rc = osd_init_iobuf(osd, iobuf, 1, npages);
 	if (unlikely(rc != 0))
 		RETURN(rc);
 
-	isize = i_size_read(inode);
-	ll_vfs_dq_init(inode);
+	disk_size = i_size_read(inode);
+	/* if disk_size is already bigger than specified user_size,
+	 * ignore user_size
+	 */
+	if (disk_size > user_size)
+		user_size = 0;
+	dquot_initialize(inode);
 
-        for (i = 0; i < npages; i++) {
+	for (i = 0; i < npages; i++) {
 		if (lnb[i].lnb_rc == -ENOSPC &&
 		    (lnb[i].lnb_flags & OBD_BRW_MAPPED)) {
 			/* Allow the write to proceed if overwriting an
@@ -1556,8 +1265,8 @@ static int osd_write_commit(const struct lu_env *env, struct dt_object *dt,
 		LASSERT(PageLocked(lnb[i].lnb_page));
 		LASSERT(!PageWriteback(lnb[i].lnb_page));
 
-		if (lnb[i].lnb_file_offset + lnb[i].lnb_len > isize)
-			isize = lnb[i].lnb_file_offset + lnb[i].lnb_len;
+		if (lnb[i].lnb_file_offset + lnb[i].lnb_len > disk_size)
+			disk_size = lnb[i].lnb_file_offset + lnb[i].lnb_len;
 
 		/*
 		 * Since write and truncate are serialized by oo_sem, even
@@ -1569,28 +1278,31 @@ static int osd_write_commit(const struct lu_env *env, struct dt_object *dt,
 		SetPageUptodate(lnb[i].lnb_page);
 
 		osd_iobuf_add_page(iobuf, &lnb[i]);
-        }
+	}
+	/* if file has grown, take user_size into account */
+	if (user_size && disk_size > user_size)
+		disk_size = user_size;
 
 	osd_trans_exec_op(env, thandle, OSD_OT_WRITE);
 
-        if (OBD_FAIL_CHECK(OBD_FAIL_OST_MAPBLK_ENOSPC)) {
-                rc = -ENOSPC;
-        } else if (iobuf->dr_npages > 0) {
+	if (OBD_FAIL_CHECK(OBD_FAIL_OST_MAPBLK_ENOSPC)) {
+		rc = -ENOSPC;
+	} else if (iobuf->dr_npages > 0) {
 		rc = osd_ldiskfs_map_inode_pages(inode, iobuf->dr_pages,
 						 iobuf->dr_npages,
 						 iobuf->dr_blocks, 1);
-        } else {
-                /* no pages to write, no transno is needed */
-                thandle->th_local = 1;
-        }
+	} else {
+		/* no pages to write, no transno is needed */
+		thandle->th_local = 1;
+	}
 
 	if (likely(rc == 0)) {
 		spin_lock(&inode->i_lock);
-		if (isize > i_size_read(inode)) {
-			i_size_write(inode, isize);
-			LDISKFS_I(inode)->i_disksize = isize;
+		if (disk_size > i_size_read(inode)) {
+			i_size_write(inode, disk_size);
+			LDISKFS_I(inode)->i_disksize = disk_size;
 			spin_unlock(&inode->i_lock);
-			ll_dirty_inode(inode, I_DIRTY_DATASYNC);
+			osd_dirty_inode(inode, I_DIRTY_DATASYNC);
 		} else {
 			spin_unlock(&inode->i_lock);
 		}
@@ -1609,9 +1321,11 @@ static int osd_write_commit(const struct lu_env *env, struct dt_object *dt,
 		for (i = 0; i < npages; i++) {
 			if (lnb[i].lnb_page == NULL)
 				continue;
-			LASSERT(PageLocked(lnb[i].lnb_page));
-			generic_error_remove_page(inode->i_mapping,
-						  lnb[i].lnb_page);
+			if (!PagePrivate2(lnb[i].lnb_page)) {
+				LASSERT(PageLocked(lnb[i].lnb_page));
+				generic_error_remove_page(inode->i_mapping,
+							  lnb[i].lnb_page);
+			}
 		}
 	}
 
@@ -1625,7 +1339,7 @@ static int osd_read_prep(const struct lu_env *env, struct dt_object *dt,
         struct osd_iobuf *iobuf = &oti->oti_iobuf;
         struct inode *inode = osd_dt_obj(dt)->oo_inode;
         struct osd_device *osd = osd_obj2dev(osd_dt_obj(dt));
-	int rc = 0, i, cache = 0, cache_hits = 0, cache_misses = 0;
+	int rc = 0, i, cache_hits = 0, cache_misses = 0;
 	ktime_t start, end;
 	s64 timediff;
 	loff_t isize;
@@ -1638,11 +1352,6 @@ static int osd_read_prep(const struct lu_env *env, struct dt_object *dt,
 
 	isize = i_size_read(inode);
 
-	if (osd->od_read_cache)
-		cache = 1;
-	if (isize > osd->od_readcache_max_filesize)
-		cache = 0;
-
 	start = ktime_get();
 	for (i = 0; i < npages; i++) {
 
@@ -1651,10 +1360,10 @@ static int osd_read_prep(const struct lu_env *env, struct dt_object *dt,
 			 * lnb->lnb_rc == 0, so it's easy to detect later. */
 			break;
 
-		if (isize < lnb[i].lnb_file_offset + lnb[i].lnb_len)
-			lnb[i].lnb_rc = isize - lnb[i].lnb_file_offset;
-		else
-			lnb[i].lnb_rc = lnb[i].lnb_len;
+		/* instead of looking if we go beyong isize, send complete
+		 * pages all the time
+		 */
+		lnb[i].lnb_rc = lnb[i].lnb_len;
 
 		/* Bypass disk read if fail_loc is set properly */
 		if (OBD_FAIL_CHECK(OBD_FAIL_OST_FAKE_RW))
@@ -1662,14 +1371,17 @@ static int osd_read_prep(const struct lu_env *env, struct dt_object *dt,
 
 		if (PageUptodate(lnb[i].lnb_page)) {
 			cache_hits++;
+			unlock_page(lnb[i].lnb_page);
 		} else {
 			cache_misses++;
 			osd_iobuf_add_page(iobuf, &lnb[i]);
 		}
-
-		if (cache == 0)
-			generic_error_remove_page(inode->i_mapping,
-						  lnb[i].lnb_page);
+		/* no need to unlock in osd_bufs_put(), the sooner page is
+		 * unlocked, the earlier another client can access it.
+		 * notice real unlock_page() can be called few lines
+		 * below after osd_do_bio(). lnb is a per-thread, so it's
+		 * fine to have PG_locked and lnb_locked inconsistent here */
+		lnb[i].lnb_locked = 0;
 	}
 	end = ktime_get();
 	timediff = ktime_us_delta(end, start);
@@ -1685,16 +1397,23 @@ static int osd_read_prep(const struct lu_env *env, struct dt_object *dt,
 		lprocfs_counter_add(osd->od_stats, LPROC_OSD_CACHE_ACCESS,
 				    cache_hits + cache_misses);
 
-        if (iobuf->dr_npages) {
+	if (iobuf->dr_npages) {
 		rc = osd_ldiskfs_map_inode_pages(inode, iobuf->dr_pages,
 						 iobuf->dr_npages,
 						 iobuf->dr_blocks, 0);
-                rc = osd_do_bio(osd, inode, iobuf);
+		rc = osd_do_bio(osd, inode, iobuf);
 
-                /* IO stats will be done in osd_bufs_put() */
-        }
+		/* IO stats will be done in osd_bufs_put() */
 
-        RETURN(rc);
+		/* early release to let others read data during the bulk */
+		for (i = 0; i < iobuf->dr_npages; i++) {
+			LASSERT(PageLocked(iobuf->dr_pages[i]));
+			if (!PagePrivate2(iobuf->dr_pages[i]))
+				unlock_page(iobuf->dr_pages[i]);
+		}
+	}
+
+	RETURN(rc);
 }
 
 /*
@@ -1777,19 +1496,27 @@ int osd_ldiskfs_read(struct inode *inode, void *buf, int size, loff_t *offs)
 static ssize_t osd_read(const struct lu_env *env, struct dt_object *dt,
 			struct lu_buf *buf, loff_t *pos)
 {
-        struct inode *inode = osd_dt_obj(dt)->oo_inode;
-        int           rc;
+	struct inode *inode = osd_dt_obj(dt)->oo_inode;
+	int rc;
 
-        /* Read small symlink from inode body as we need to maintain correct
-         * on-disk symlinks for ldiskfs.
-         */
-        if (S_ISLNK(dt->do_lu.lo_header->loh_attr) &&
-            (buf->lb_len < sizeof(LDISKFS_I(inode)->i_data)))
-                rc = osd_ldiskfs_readlink(inode, buf->lb_buf, buf->lb_len);
-        else
-                rc = osd_ldiskfs_read(inode, buf->lb_buf, buf->lb_len, pos);
+	/* Read small symlink from inode body as we need to maintain correct
+	 * on-disk symlinks for ldiskfs.
+	 */
+	if (S_ISLNK(dt->do_lu.lo_header->loh_attr)) {
+		loff_t size = i_size_read(inode);
 
-        return rc;
+		if (buf->lb_len < size)
+			return -EOVERFLOW;
+
+		if (size < sizeof(LDISKFS_I(inode)->i_data))
+			rc = osd_ldiskfs_readlink(inode, buf->lb_buf, size);
+		else
+			rc = osd_ldiskfs_read(inode, buf->lb_buf, size, pos);
+	} else {
+		rc = osd_ldiskfs_read(inode, buf->lb_buf, buf->lb_len, pos);
+	}
+
+	return rc;
 }
 
 static inline int osd_extents_enabled(struct super_block *sb,
@@ -1867,10 +1594,10 @@ static ssize_t osd_declare_write(const struct lu_env *env, struct dt_object *dt,
 	ENTRY;
 
 	LASSERT(buf != NULL);
-        LASSERT(handle != NULL);
+	LASSERT(handle != NULL);
 
-        oh = container_of0(handle, struct osd_thandle, ot_super);
-        LASSERT(oh->ot_handle == NULL);
+	oh = container_of(handle, struct osd_thandle, ot_super);
+	LASSERT(oh->ot_handle == NULL);
 
 	size = buf->lb_len;
 	bits = sb->s_blocksize_bits;
@@ -1955,23 +1682,27 @@ static int osd_ldiskfs_writelink(struct inode *inode, char *buffer, int buflen)
 	LDISKFS_I(inode)->i_disksize = buflen;
 	i_size_write(inode, buflen);
 	spin_unlock(&inode->i_lock);
-	ll_dirty_inode(inode, I_DIRTY_DATASYNC);
+	osd_dirty_inode(inode, I_DIRTY_DATASYNC);
 
 	return 0;
 }
 
-int osd_ldiskfs_write_record(struct inode *inode, void *buf, int bufsize,
-			     int write_NUL, loff_t *offs, handle_t *handle)
+static int osd_ldiskfs_write_record(struct dt_object *dt, void *buf,
+				    int bufsize, int write_NUL, loff_t *offs,
+				    handle_t *handle)
 {
+	struct inode *inode = osd_dt_obj(dt)->oo_inode;
         struct buffer_head *bh        = NULL;
         loff_t              offset    = *offs;
         loff_t              new_size  = i_size_read(inode);
         unsigned long       block;
         int                 blocksize = 1 << inode->i_blkbits;
+	struct ldiskfs_inode_info *ei = LDISKFS_I(inode);
         int                 err = 0;
         int                 size;
         int                 boffs;
         int                 dirty_inode = 0;
+	bool create, sparse, sync = false;
 
 	if (write_NUL) {
 		/*
@@ -1983,8 +1714,16 @@ int osd_ldiskfs_write_record(struct inode *inode, void *buf, int bufsize,
 		++bufsize;
 	}
 
+	dirty_inode = test_and_set_bit(LDISKFS_INODE_JOURNAL_DATA, &ei->i_flags);
+
+	/* sparse checking is racy, but sparse is very rare case, leave as is */
+	sparse = (new_size > 0 && (inode->i_blocks >> (inode->i_blkbits - 9)) <
+		  ((new_size - 1) >> inode->i_blkbits) + 1);
+
 	while (bufsize > 0) {
 		int credits = handle->h_buffer_credits;
+		unsigned long last_block = (new_size == 0) ? 0 :
+					   (new_size - 1) >> inode->i_blkbits;
 
 		if (bh)
 			brelse(bh);
@@ -1992,7 +1731,39 @@ int osd_ldiskfs_write_record(struct inode *inode, void *buf, int bufsize,
 		block = offset >> inode->i_blkbits;
 		boffs = offset & (blocksize - 1);
 		size = min(blocksize - boffs, bufsize);
-		bh = __ldiskfs_bread(handle, inode, block, 1);
+		sync = (block > last_block || new_size == 0 || sparse);
+
+		if (sync)
+			down(&ei->i_append_sem);
+
+		bh = __ldiskfs_bread(handle, inode, block, 0);
+
+		if (unlikely(IS_ERR_OR_NULL(bh) && !sync))
+			CWARN("%s: adding bh without locking off %llu (block %lu, "
+			      "size %d, offs %llu)\n", inode->i_sb->s_id,
+			      offset, block, bufsize, *offs);
+
+		if (IS_ERR_OR_NULL(bh)) {
+			struct osd_device *osd = osd_obj2dev(osd_dt_obj(dt));
+			int flags = LDISKFS_GET_BLOCKS_CREATE;
+
+			/* while the file system is being mounted, avoid
+			 * preallocation otherwise mount can take a long
+			 * time as mballoc cache is cold.
+			 * XXX: this is a workaround until we have a proper
+			 *	fix in mballoc
+			 * XXX: works with extent-based files only */
+			if (!osd->od_cl_seq)
+				flags |= LDISKFS_GET_BLOCKS_NO_NORMALIZE;
+			bh = __ldiskfs_bread(handle, inode, block, flags);
+			create = true;
+		} else {
+			if (sync) {
+				up(&ei->i_append_sem);
+				sync = false;
+			}
+			create = false;
+		}
 		if (IS_ERR_OR_NULL(bh)) {
 			if (bh == NULL) {
 				err = -EIO;
@@ -2017,7 +1788,14 @@ int osd_ldiskfs_write_record(struct inode *inode, void *buf, int bufsize,
 		LASSERTF(boffs + size <= bh->b_size,
 			 "boffs %d size %d bh->b_size %lu\n",
 			 boffs, size, (unsigned long)bh->b_size);
-                memcpy(bh->b_data + boffs, buf, size);
+		if (create) {
+			memset(bh->b_data, 0, bh->b_size);
+			if (sync) {
+				up(&ei->i_append_sem);
+				sync = false;
+			}
+		}
+		memcpy(bh->b_data + boffs, buf, size);
 		err = ldiskfs_handle_dirty_metadata(handle, NULL, bh);
                 if (err)
                         break;
@@ -2028,8 +1806,11 @@ int osd_ldiskfs_write_record(struct inode *inode, void *buf, int bufsize,
                 bufsize -= size;
                 buf += size;
         }
-        if (bh)
-                brelse(bh);
+	if (sync)
+		up(&ei->i_append_sem);
+
+	if (bh)
+		brelse(bh);
 
 	if (write_NUL)
 		--new_size;
@@ -2038,14 +1819,14 @@ int osd_ldiskfs_write_record(struct inode *inode, void *buf, int bufsize,
 		spin_lock(&inode->i_lock);
 		if (new_size > i_size_read(inode))
 			i_size_write(inode, new_size);
-		if (i_size_read(inode) > LDISKFS_I(inode)->i_disksize) {
-			LDISKFS_I(inode)->i_disksize = i_size_read(inode);
+		if (i_size_read(inode) > ei->i_disksize) {
+			ei->i_disksize = i_size_read(inode);
 			dirty_inode = 1;
 		}
 		spin_unlock(&inode->i_lock);
-		if (dirty_inode)
-			ll_dirty_inode(inode, I_DIRTY_DATASYNC);
         }
+	if (dirty_inode)
+		osd_dirty_inode(inode, I_DIRTY_DATASYNC);
 
         if (err == 0)
                 *offs = offset;
@@ -2065,7 +1846,7 @@ static ssize_t osd_write(const struct lu_env *env, struct dt_object *dt,
 
         LASSERT(handle != NULL);
 	LASSERT(inode != NULL);
-	ll_vfs_dq_init(inode);
+	dquot_initialize(inode);
 
         /* XXX: don't check: one declared chunk can be used many times */
 	/* osd_trans_exec_op(env, handle, OSD_OT_WRITE); */
@@ -2083,9 +1864,8 @@ static ssize_t osd_write(const struct lu_env *env, struct dt_object *dt,
 	if (is_link && (buf->lb_len < sizeof(LDISKFS_I(inode)->i_data)))
 		result = osd_ldiskfs_writelink(inode, buf->lb_buf, buf->lb_len);
 	else
-		result = osd_ldiskfs_write_record(inode, buf->lb_buf,
-						  buf->lb_len, is_link, pos,
-						  oh->ot_handle);
+		result = osd_ldiskfs_write_record(dt, buf->lb_buf, buf->lb_len,
+						  is_link, pos, oh->ot_handle);
 	if (result == 0)
 		result = buf->lb_len;
 
@@ -2094,6 +1874,69 @@ static ssize_t osd_write(const struct lu_env *env, struct dt_object *dt,
 	return result;
 }
 
+static int osd_declare_fallocate(const struct lu_env *env,
+				 struct dt_object *dt, struct thandle *th)
+{
+	struct osd_thandle *oh;
+	struct inode *inode;
+	int rc;
+	ENTRY;
+
+	LASSERT(th);
+	oh = container_of(th, struct osd_thandle, ot_super);
+
+	osd_trans_declare_op(env, oh, OSD_OT_PREALLOC,
+			     osd_dto_credits_noquota[DTO_WRITE_BLOCK]);
+	inode = osd_dt_obj(dt)->oo_inode;
+	LASSERT(inode);
+
+	rc = osd_declare_inode_qid(env, i_uid_read(inode), i_gid_read(inode),
+				   i_projid_read(inode), 0, oh, osd_dt_obj(dt),
+				   NULL, OSD_QID_BLK);
+	RETURN(rc);
+}
+
+static int osd_fallocate(const struct lu_env *env, struct dt_object *dt,
+			 __u64 start, __u64 end, int mode, struct thandle *th)
+{
+	struct osd_object *obj = osd_dt_obj(dt);
+	struct inode *inode = obj->oo_inode;
+	int rc = 0;
+	struct osd_thread_info *info = osd_oti_get(env);
+	struct dentry *dentry = &info->oti_obj_dentry;
+	struct file *file = &info->oti_file;
+
+	ENTRY;
+	/*
+	 * Only mode == 0 (which is standard prealloc) is supported now.
+	 * Rest of mode options is not supported yet.
+	 */
+	if (mode & ~FALLOC_FL_KEEP_SIZE)
+		RETURN(-EOPNOTSUPP);
+
+	LASSERT(dt_object_exists(dt));
+	LASSERT(osd_invariant(obj));
+	LASSERT(inode != NULL);
+	dquot_initialize(inode);
+
+	LASSERT(th);
+
+	osd_trans_exec_op(env, th, OSD_OT_PREALLOC);
+
+	/*
+	 * Because f_op->fallocate() does not have an inode arg
+	 */
+	dentry->d_inode = inode;
+	dentry->d_sb = inode->i_sb;
+	file->f_path.dentry = dentry;
+	file->f_mapping = inode->i_mapping;
+	file->f_op = inode->i_fop;
+	file->f_inode = inode;
+	rc = file->f_op->fallocate(file, mode, start, end - start);
+
+	RETURN(rc);
+}
+
 static int osd_declare_punch(const struct lu_env *env, struct dt_object *dt,
                              __u64 start, __u64 end, struct thandle *th)
 {
@@ -2141,11 +1984,10 @@ static int osd_punch(const struct lu_env *env, struct dt_object *dt,
 	bool grow = false;
 	ENTRY;
 
-	LASSERT(end == OBD_OBJECT_EOF);
 	LASSERT(dt_object_exists(dt));
 	LASSERT(osd_invariant(obj));
 	LASSERT(inode != NULL);
-	ll_vfs_dq_init(inode);
+	dquot_initialize(inode);
 
 	LASSERT(th);
 	oh = container_of(th, struct osd_thandle, ot_super);
@@ -2176,10 +2018,12 @@ static int osd_punch(const struct lu_env *env, struct dt_object *dt,
 		GOTO(out, rc);
 	}
 
+	inode_lock(inode);
 	/* add to orphan list to ensure truncate completion
 	 * if this transaction succeed. ldiskfs_truncate()
 	 * will take the inode out of the list */
 	rc = ldiskfs_orphan_add(oh->ot_handle, inode);
+	inode_unlock(inode);
 	if (rc != 0)
 		GOTO(out, rc);
 
@@ -2273,17 +2117,16 @@ static int osd_fiemap_get(const struct lu_env *env, struct dt_object *dt,
 static int osd_ladvise(const struct lu_env *env, struct dt_object *dt,
 		       __u64 start, __u64 end, enum lu_ladvise_type advice)
 {
-	int		 rc = 0;
-	struct inode	*inode = osd_dt_obj(dt)->oo_inode;
+	struct osd_object *obj = osd_dt_obj(dt);
+	int rc = 0;
 	ENTRY;
 
 	switch (advice) {
 	case LU_LADVISE_DONTNEED:
-		if (end == 0)
-			break;
-		invalidate_mapping_pages(inode->i_mapping,
-					 start >> PAGE_SHIFT,
-					 (end - 1) >> PAGE_SHIFT);
+		if (end)
+			invalidate_mapping_pages(obj->oo_inode->i_mapping,
+						 start >> PAGE_SHIFT,
+						 (end - 1) >> PAGE_SHIFT);
 		break;
 	default:
 		rc = -ENOTSUPP;
@@ -2315,6 +2158,8 @@ const struct dt_body_operations osd_body_ops = {
 	.dbo_punch			= osd_punch,
 	.dbo_fiemap_get			= osd_fiemap_get,
 	.dbo_ladvise			= osd_ladvise,
+	.dbo_declare_fallocate		= osd_declare_fallocate,
+	.dbo_fallocate			= osd_fallocate,
 };
 
 /**
@@ -2359,13 +2204,14 @@ int osd_trunc_lock(struct osd_object *obj, struct osd_thandle *oh, bool shared)
 	else
 		down_write(&obj->oo_ext_idx_sem);
 	al->tl_shared = shared;
+	lu_object_get(&obj->oo_dt.do_lu);
 
 	list_add(&al->tl_list, &oh->ot_trunc_locks);
 
 	return 0;
 }
 
-void osd_trunc_unlock_all(struct list_head *list)
+void osd_trunc_unlock_all(const struct lu_env *env, struct list_head *list)
 {
 	struct osd_access_lock *al, *tmp;
 	list_for_each_entry_safe(al, tmp, list, tl_list) {
@@ -2373,6 +2219,7 @@ void osd_trunc_unlock_all(struct list_head *list)
 			up_read(&al->tl_obj->oo_ext_idx_sem);
 		else
 			up_write(&al->tl_obj->oo_ext_idx_sem);
+		osd_object_put(env, al->tl_obj);
 		list_del(&al->tl_list);
 		OBD_FREE_PTR(al);
 	}
@@ -2395,7 +2242,9 @@ void osd_execute_truncate(struct osd_object *obj)
 		return;
 	}
 
+	inode_lock(inode);
 	ldiskfs_truncate(inode);
+	inode_unlock(inode);
 
 	/*
 	 * For a partial-page truncate, flush the page to disk immediately to