inline.c 12 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * fs/f2fs/inline.c
 * Copyright (c) 2013, Intel Corporation
 * Authors: Huajun Li <huajun.li@intel.com>
 *          Haicheng Li <haicheng.li@intel.com>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/fs.h>
#include <linux/f2fs_fs.h>

#include "f2fs.h"

bool f2fs_may_inline(struct inode *inode)
{
18
	if (!test_opt(F2FS_I_SB(inode), INLINE_DATA))
19 20
		return false;

Jaegeuk Kim's avatar
Jaegeuk Kim committed
21 22 23
	if (f2fs_is_atomic_file(inode))
		return false;

24
	if (!S_ISREG(inode->i_mode))
25 26
		return false;

27 28 29
	if (i_size_read(inode) > MAX_INLINE_DATA)
		return false;

30 31 32
	return true;
}

33
void read_inline_data(struct page *page, struct page *ipage)
34 35 36
{
	void *src_addr, *dst_addr;

37 38
	if (PageUptodate(page))
		return;
39

40
	f2fs_bug_on(F2FS_P_SB(page), page->index);
41

42
	zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
43 44 45

	/* Copy the whole inline data block */
	src_addr = inline_data_addr(ipage);
46
	dst_addr = kmap_atomic(page);
47
	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
48
	flush_dcache_page(page);
49
	kunmap_atomic(dst_addr);
50
	SetPageUptodate(page);
51 52 53 54 55 56 57 58 59 60 61
}

int f2fs_read_inline_data(struct inode *inode, struct page *page)
{
	struct page *ipage;

	ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
	if (IS_ERR(ipage)) {
		unlock_page(page);
		return PTR_ERR(ipage);
	}
62

63 64 65 66 67 68 69 70 71 72 73 74 75
	if (!f2fs_has_inline_data(inode)) {
		f2fs_put_page(ipage, 1);
		return -EAGAIN;
	}

	if (page->index)
		zero_user_segment(page, 0, PAGE_CACHE_SIZE);
	else
		read_inline_data(page, ipage);

	SetPageUptodate(page);
	f2fs_put_page(ipage, 1);
	unlock_page(page);
76 77 78
	return 0;
}

79
int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
80 81 82 83 84 85 86
{
	void *src_addr, *dst_addr;
	block_t new_blk_addr;
	struct f2fs_io_info fio = {
		.type = DATA,
		.rw = WRITE_SYNC | REQ_PRIO,
	};
87
	int err;
88

89
	f2fs_bug_on(F2FS_I_SB(dn->inode), page->index);
90

91 92
	if (!f2fs_exist_data(dn->inode))
		goto clear_out;
93

94
	err = f2fs_reserve_block(dn, 0);
95
	if (err)
96
		return err;
97

98
	f2fs_wait_on_page_writeback(page, DATA);
99 100 101 102

	if (PageUptodate(page))
		goto no_update;

103
	zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
104 105

	/* Copy the whole inline data block */
106
	src_addr = inline_data_addr(dn->inode_page);
107
	dst_addr = kmap_atomic(page);
108
	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
109
	kunmap_atomic(dst_addr);
110
	SetPageUptodate(page);
111
no_update:
112 113
	/* write data page to try to make data consistent */
	set_page_writeback(page);
114 115 116

	write_data_page(page, dn, &new_blk_addr, &fio);
	update_extent_cache(new_blk_addr, dn);
117
	f2fs_wait_on_page_writeback(page, DATA);
118 119

	/* clear inline data and flag after data writeback */
120 121 122
	truncate_inline_data(dn->inode_page, 0);
clear_out:
	stat_dec_inline_inode(dn->inode);
123
	f2fs_clear_inline_inode(dn->inode);
124 125 126
	sync_inode_page(dn);
	f2fs_put_dnode(dn);
	return 0;
127 128
}

129
int f2fs_convert_inline_inode(struct inode *inode)
130
{
131 132 133 134
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
	struct dnode_of_data dn;
	struct page *ipage, *page;
	int err = 0;
135

136 137 138
	page = grab_cache_page(inode->i_mapping, 0);
	if (!page)
		return -ENOMEM;
139

140 141 142 143 144 145
	f2fs_lock_op(sbi);

	ipage = get_node_page(sbi, inode->i_ino);
	if (IS_ERR(ipage)) {
		f2fs_unlock_op(sbi);
		return PTR_ERR(ipage);
146
	}
147

148 149 150 151 152 153 154 155 156 157
	set_new_dnode(&dn, inode, ipage, ipage, 0);

	if (f2fs_has_inline_data(inode))
		err = f2fs_convert_inline_page(&dn, page);

	f2fs_put_dnode(&dn);

	f2fs_unlock_op(sbi);

	f2fs_put_page(page, 1);
158 159 160
	return err;
}

161
int f2fs_write_inline_data(struct inode *inode, struct page *page)
162 163 164 165 166 167 168 169 170 171
{
	void *src_addr, *dst_addr;
	struct dnode_of_data dn;
	int err;

	set_new_dnode(&dn, inode, NULL, NULL, 0);
	err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
	if (err)
		return err;

172
	if (!f2fs_has_inline_data(inode)) {
173 174
		f2fs_put_dnode(&dn);
		return -EAGAIN;
175 176
	}

177 178 179
	f2fs_bug_on(F2FS_I_SB(inode), page->index);

	f2fs_wait_on_page_writeback(dn.inode_page, NODE);
180
	src_addr = kmap_atomic(page);
181 182
	dst_addr = inline_data_addr(dn.inode_page);
	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
183
	kunmap_atomic(src_addr);
184

185
	set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
186 187
	set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);

188 189 190 191
	sync_inode_page(&dn);
	f2fs_put_dnode(&dn);
	return 0;
}
192

193
void truncate_inline_data(struct page *ipage, u64 from)
194
{
195
	void *addr;
196 197 198 199

	if (from >= MAX_INLINE_DATA)
		return;

200 201
	f2fs_wait_on_page_writeback(ipage, NODE);

202 203
	addr = inline_data_addr(ipage);
	memset(addr + from, 0, MAX_INLINE_DATA - from);
204 205
}

206
bool recover_inline_data(struct inode *inode, struct page *npage)
207
{
208
	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
	struct f2fs_inode *ri = NULL;
	void *src_addr, *dst_addr;
	struct page *ipage;

	/*
	 * The inline_data recovery policy is as follows.
	 * [prev.] [next] of inline_data flag
	 *    o       o  -> recover inline_data
	 *    o       x  -> remove inline_data, and then recover data blocks
	 *    x       o  -> remove inline_data, and then recover inline_data
	 *    x       x  -> recover data blocks
	 */
	if (IS_INODE(npage))
		ri = F2FS_INODE(npage);

	if (f2fs_has_inline_data(inode) &&
225
			ri && (ri->i_inline & F2FS_INLINE_DATA)) {
226 227
process_inline:
		ipage = get_node_page(sbi, inode->i_ino);
228
		f2fs_bug_on(sbi, IS_ERR(ipage));
229

230 231
		f2fs_wait_on_page_writeback(ipage, NODE);

232 233 234
		src_addr = inline_data_addr(npage);
		dst_addr = inline_data_addr(ipage);
		memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
235 236 237 238

		set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
		set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);

239 240
		update_inode(inode, ipage);
		f2fs_put_page(ipage, 1);
241
		return true;
242 243 244 245
	}

	if (f2fs_has_inline_data(inode)) {
		ipage = get_node_page(sbi, inode->i_ino);
246
		f2fs_bug_on(sbi, IS_ERR(ipage));
247 248
		truncate_inline_data(ipage, 0);
		f2fs_clear_inline_inode(inode);
249 250
		update_inode(inode, ipage);
		f2fs_put_page(ipage, 1);
251
	} else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
252
		truncate_blocks(inode, 0, false);
253 254
		goto process_inline;
	}
255
	return false;
256
}
257 258 259 260 261

struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
				struct qstr *name, struct page **res_page)
{
	struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
262
	struct f2fs_inline_dentry *inline_dentry;
263
	struct f2fs_dir_entry *de;
264
	struct f2fs_dentry_ptr d;
265
	struct page *ipage;
266 267 268 269 270

	ipage = get_node_page(sbi, dir->i_ino);
	if (IS_ERR(ipage))
		return NULL;

271
	inline_dentry = inline_data_addr(ipage);
272

273 274 275
	make_dentry_ptr(&d, (void *)inline_dentry, 2);
	de = find_target_dentry(name, NULL, &d);

276
	unlock_page(ipage);
277 278 279 280 281 282 283 284 285
	if (de)
		*res_page = ipage;
	else
		f2fs_put_page(ipage, 0);

	/*
	 * For the most part, it should be a bug when name_len is zero.
	 * We stop here for figuring out where the bugs has occurred.
	 */
286
	f2fs_bug_on(sbi, d.max < 0);
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312
	return de;
}

struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *dir,
							struct page **p)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
	struct page *ipage;
	struct f2fs_dir_entry *de;
	struct f2fs_inline_dentry *dentry_blk;

	ipage = get_node_page(sbi, dir->i_ino);
	if (IS_ERR(ipage))
		return NULL;

	dentry_blk = inline_data_addr(ipage);
	de = &dentry_blk->dentry[1];
	*p = ipage;
	unlock_page(ipage);
	return de;
}

int make_empty_inline_dir(struct inode *inode, struct inode *parent,
							struct page *ipage)
{
	struct f2fs_inline_dentry *dentry_blk;
313
	struct f2fs_dentry_ptr d;
314 315 316

	dentry_blk = inline_data_addr(ipage);

317 318
	make_dentry_ptr(&d, (void *)dentry_blk, 2);
	do_make_empty_dir(inode, parent, &d);
319 320 321 322 323 324 325 326 327 328 329

	set_page_dirty(ipage);

	/* update i_size to MAX_INLINE_DATA */
	if (i_size_read(inode) < MAX_INLINE_DATA) {
		i_size_write(inode, MAX_INLINE_DATA);
		set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
	}
	return 0;
}

330
static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
				struct f2fs_inline_dentry *inline_dentry)
{
	struct page *page;
	struct dnode_of_data dn;
	struct f2fs_dentry_block *dentry_blk;
	int err;

	page = grab_cache_page(dir->i_mapping, 0);
	if (!page)
		return -ENOMEM;

	set_new_dnode(&dn, dir, ipage, NULL, 0);
	err = f2fs_reserve_block(&dn, 0);
	if (err)
		goto out;

	f2fs_wait_on_page_writeback(page, DATA);
	zero_user_segment(page, 0, PAGE_CACHE_SIZE);

350
	dentry_blk = kmap_atomic(page);
351 352 353 354 355 356 357 358 359

	/* copy data from inline dentry block to new dentry block */
	memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap,
					INLINE_DENTRY_BITMAP_SIZE);
	memcpy(dentry_blk->dentry, inline_dentry->dentry,
			sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY);
	memcpy(dentry_blk->filename, inline_dentry->filename,
					NR_INLINE_DENTRY * F2FS_SLOT_LEN);

360
	kunmap_atomic(dentry_blk);
361 362 363 364
	SetPageUptodate(page);
	set_page_dirty(page);

	/* clear inline dir and flag after data writeback */
365 366
	truncate_inline_data(ipage, 0);

367
	stat_dec_inline_dir(dir);
Chao Yu's avatar
Chao Yu committed
368
	clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY);
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402

	if (i_size_read(dir) < PAGE_CACHE_SIZE) {
		i_size_write(dir, PAGE_CACHE_SIZE);
		set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
	}

	sync_inode_page(&dn);
out:
	f2fs_put_page(page, 1);
	return err;
}

int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
						struct inode *inode)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
	struct page *ipage;
	unsigned int bit_pos;
	f2fs_hash_t name_hash;
	struct f2fs_dir_entry *de;
	size_t namelen = name->len;
	struct f2fs_inline_dentry *dentry_blk = NULL;
	int slots = GET_DENTRY_SLOTS(namelen);
	struct page *page;
	int err = 0;
	int i;

	name_hash = f2fs_dentry_hash(name);

	ipage = get_node_page(sbi, dir->i_ino);
	if (IS_ERR(ipage))
		return PTR_ERR(ipage);

	dentry_blk = inline_data_addr(ipage);
403 404
	bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
						slots, NR_INLINE_DENTRY);
405 406 407 408 409 410 411 412
	if (bit_pos >= NR_INLINE_DENTRY) {
		err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);
		if (!err)
			err = -EAGAIN;
		goto out;
	}

	down_write(&F2FS_I(inode)->i_sem);
413
	page = init_inode_metadata(inode, dir, name, ipage);
414 415 416 417
	if (IS_ERR(page)) {
		err = PTR_ERR(page);
		goto fail;
	}
418 419

	f2fs_wait_on_page_writeback(ipage, NODE);
420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
	de = &dentry_blk->dentry[bit_pos];
	de->hash_code = name_hash;
	de->name_len = cpu_to_le16(namelen);
	memcpy(dentry_blk->filename[bit_pos], name->name, name->len);
	de->ino = cpu_to_le32(inode->i_ino);
	set_de_type(de, inode);
	for (i = 0; i < slots; i++)
		test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
	set_page_dirty(ipage);

	/* we don't need to mark_inode_dirty now */
	F2FS_I(inode)->i_pino = dir->i_ino;
	update_inode(inode, page);
	f2fs_put_page(page, 1);

	update_parent_metadata(dir, inode, 0);
fail:
	up_write(&F2FS_I(inode)->i_sem);

	if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
		update_inode(dir, ipage);
		clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
	}
out:
	f2fs_put_page(ipage, 1);
	return err;
}

void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
					struct inode *dir, struct inode *inode)
{
	struct f2fs_inline_dentry *inline_dentry;
	int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
	unsigned int bit_pos;
	int i;

	lock_page(page);
457
	f2fs_wait_on_page_writeback(page, NODE);
458 459 460 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 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503

	inline_dentry = inline_data_addr(page);
	bit_pos = dentry - inline_dentry->dentry;
	for (i = 0; i < slots; i++)
		test_and_clear_bit_le(bit_pos + i,
				&inline_dentry->dentry_bitmap);

	set_page_dirty(page);

	dir->i_ctime = dir->i_mtime = CURRENT_TIME;

	if (inode)
		f2fs_drop_nlink(dir, inode, page);

	f2fs_put_page(page, 1);
}

bool f2fs_empty_inline_dir(struct inode *dir)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
	struct page *ipage;
	unsigned int bit_pos = 2;
	struct f2fs_inline_dentry *dentry_blk;

	ipage = get_node_page(sbi, dir->i_ino);
	if (IS_ERR(ipage))
		return false;

	dentry_blk = inline_data_addr(ipage);
	bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
					NR_INLINE_DENTRY,
					bit_pos);

	f2fs_put_page(ipage, 1);

	if (bit_pos < NR_INLINE_DENTRY)
		return false;

	return true;
}

int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx)
{
	struct inode *inode = file_inode(file);
	struct f2fs_inline_dentry *inline_dentry = NULL;
	struct page *ipage = NULL;
504
	struct f2fs_dentry_ptr d;
505 506 507 508

	if (ctx->pos == NR_INLINE_DENTRY)
		return 0;

509
	ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
510 511 512 513 514
	if (IS_ERR(ipage))
		return PTR_ERR(ipage);

	inline_dentry = inline_data_addr(ipage);

515 516 517
	make_dentry_ptr(&d, (void *)inline_dentry, 2);

	if (!f2fs_fill_dentries(ctx, &d, 0))
518
		ctx->pos = NR_INLINE_DENTRY;
519

520
	f2fs_put_page(ipage, 1);
521 522
	return 0;
}