1
2
3
4
5
6
7
8
9
10
11#include <linux/fs.h>
12#include <linux/f2fs_fs.h>
13
14#include "f2fs.h"
15#include "node.h"
16
17bool f2fs_may_inline_data(struct inode *inode)
18{
19 if (!test_opt(F2FS_I_SB(inode), INLINE_DATA))
20 return false;
21
22 if (f2fs_is_atomic_file(inode))
23 return false;
24
25 if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
26 return false;
27
28 if (i_size_read(inode) > MAX_INLINE_DATA)
29 return false;
30
31 if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
32 return false;
33
34 return true;
35}
36
37bool f2fs_may_inline_dentry(struct inode *inode)
38{
39 if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
40 return false;
41
42 if (!S_ISDIR(inode->i_mode))
43 return false;
44
45 return true;
46}
47
48void read_inline_data(struct page *page, struct page *ipage)
49{
50 void *src_addr, *dst_addr;
51
52 if (PageUptodate(page))
53 return;
54
55 f2fs_bug_on(F2FS_P_SB(page), page->index);
56
57 zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
58
59
60 src_addr = inline_data_addr(ipage);
61 dst_addr = kmap_atomic(page);
62 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
63 flush_dcache_page(page);
64 kunmap_atomic(dst_addr);
65 SetPageUptodate(page);
66}
67
68bool truncate_inline_inode(struct page *ipage, u64 from)
69{
70 void *addr;
71
72 if (from >= MAX_INLINE_DATA)
73 return false;
74
75 addr = inline_data_addr(ipage);
76
77 f2fs_wait_on_page_writeback(ipage, NODE);
78 memset(addr + from, 0, MAX_INLINE_DATA - from);
79
80 return true;
81}
82
83int f2fs_read_inline_data(struct inode *inode, struct page *page)
84{
85 struct page *ipage;
86
87 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
88 if (IS_ERR(ipage)) {
89 unlock_page(page);
90 return PTR_ERR(ipage);
91 }
92
93 if (!f2fs_has_inline_data(inode)) {
94 f2fs_put_page(ipage, 1);
95 return -EAGAIN;
96 }
97
98 if (page->index)
99 zero_user_segment(page, 0, PAGE_CACHE_SIZE);
100 else
101 read_inline_data(page, ipage);
102
103 SetPageUptodate(page);
104 f2fs_put_page(ipage, 1);
105 unlock_page(page);
106 return 0;
107}
108
109int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
110{
111 void *src_addr, *dst_addr;
112 struct f2fs_io_info fio = {
113 .sbi = F2FS_I_SB(dn->inode),
114 .type = DATA,
115 .rw = WRITE_SYNC | REQ_PRIO,
116 .page = page,
117 .encrypted_page = NULL,
118 };
119 int dirty, err;
120
121 f2fs_bug_on(F2FS_I_SB(dn->inode), page->index);
122
123 if (!f2fs_exist_data(dn->inode))
124 goto clear_out;
125
126 err = f2fs_reserve_block(dn, 0);
127 if (err)
128 return err;
129
130 f2fs_wait_on_page_writeback(page, DATA);
131
132 if (PageUptodate(page))
133 goto no_update;
134
135 zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
136
137
138 src_addr = inline_data_addr(dn->inode_page);
139 dst_addr = kmap_atomic(page);
140 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
141 flush_dcache_page(page);
142 kunmap_atomic(dst_addr);
143 SetPageUptodate(page);
144no_update:
145 set_page_dirty(page);
146
147
148 dirty = clear_page_dirty_for_io(page);
149
150
151 set_page_writeback(page);
152 fio.blk_addr = dn->data_blkaddr;
153 write_data_page(dn, &fio);
154 set_data_blkaddr(dn);
155 f2fs_update_extent_cache(dn);
156 f2fs_wait_on_page_writeback(page, DATA);
157 if (dirty)
158 inode_dec_dirty_pages(dn->inode);
159
160
161 set_inode_flag(F2FS_I(dn->inode), FI_APPEND_WRITE);
162
163
164 truncate_inline_inode(dn->inode_page, 0);
165clear_out:
166 stat_dec_inline_inode(dn->inode);
167 f2fs_clear_inline_inode(dn->inode);
168 sync_inode_page(dn);
169 f2fs_put_dnode(dn);
170 return 0;
171}
172
173int f2fs_convert_inline_inode(struct inode *inode)
174{
175 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
176 struct dnode_of_data dn;
177 struct page *ipage, *page;
178 int err = 0;
179
180 page = grab_cache_page(inode->i_mapping, 0);
181 if (!page)
182 return -ENOMEM;
183
184 f2fs_lock_op(sbi);
185
186 ipage = get_node_page(sbi, inode->i_ino);
187 if (IS_ERR(ipage)) {
188 err = PTR_ERR(ipage);
189 goto out;
190 }
191
192 set_new_dnode(&dn, inode, ipage, ipage, 0);
193
194 if (f2fs_has_inline_data(inode))
195 err = f2fs_convert_inline_page(&dn, page);
196
197 f2fs_put_dnode(&dn);
198out:
199 f2fs_unlock_op(sbi);
200
201 f2fs_put_page(page, 1);
202 return err;
203}
204
205int f2fs_write_inline_data(struct inode *inode, struct page *page)
206{
207 void *src_addr, *dst_addr;
208 struct dnode_of_data dn;
209 int err;
210
211 set_new_dnode(&dn, inode, NULL, NULL, 0);
212 err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
213 if (err)
214 return err;
215
216 if (!f2fs_has_inline_data(inode)) {
217 f2fs_put_dnode(&dn);
218 return -EAGAIN;
219 }
220
221 f2fs_bug_on(F2FS_I_SB(inode), page->index);
222
223 f2fs_wait_on_page_writeback(dn.inode_page, NODE);
224 src_addr = kmap_atomic(page);
225 dst_addr = inline_data_addr(dn.inode_page);
226 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
227 kunmap_atomic(src_addr);
228
229 set_inode_flag(F2FS_I(inode), FI_APPEND_WRITE);
230 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
231
232 sync_inode_page(&dn);
233 f2fs_put_dnode(&dn);
234 return 0;
235}
236
237bool recover_inline_data(struct inode *inode, struct page *npage)
238{
239 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
240 struct f2fs_inode *ri = NULL;
241 void *src_addr, *dst_addr;
242 struct page *ipage;
243
244
245
246
247
248
249
250
251
252 if (IS_INODE(npage))
253 ri = F2FS_INODE(npage);
254
255 if (f2fs_has_inline_data(inode) &&
256 ri && (ri->i_inline & F2FS_INLINE_DATA)) {
257process_inline:
258 ipage = get_node_page(sbi, inode->i_ino);
259 f2fs_bug_on(sbi, IS_ERR(ipage));
260
261 f2fs_wait_on_page_writeback(ipage, NODE);
262
263 src_addr = inline_data_addr(npage);
264 dst_addr = inline_data_addr(ipage);
265 memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
266
267 set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
268 set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);
269
270 update_inode(inode, ipage);
271 f2fs_put_page(ipage, 1);
272 return true;
273 }
274
275 if (f2fs_has_inline_data(inode)) {
276 ipage = get_node_page(sbi, inode->i_ino);
277 f2fs_bug_on(sbi, IS_ERR(ipage));
278 if (!truncate_inline_inode(ipage, 0))
279 return false;
280 f2fs_clear_inline_inode(inode);
281 update_inode(inode, ipage);
282 f2fs_put_page(ipage, 1);
283 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
284 if (truncate_blocks(inode, 0, false))
285 return false;
286 goto process_inline;
287 }
288 return false;
289}
290
291struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir,
292 struct f2fs_filename *fname, struct page **res_page)
293{
294 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
295 struct f2fs_inline_dentry *inline_dentry;
296 struct qstr name = FSTR_TO_QSTR(&fname->disk_name);
297 struct f2fs_dir_entry *de;
298 struct f2fs_dentry_ptr d;
299 struct page *ipage;
300 f2fs_hash_t namehash;
301
302 ipage = get_node_page(sbi, dir->i_ino);
303 if (IS_ERR(ipage))
304 return NULL;
305
306 namehash = f2fs_dentry_hash(&name);
307
308 inline_dentry = inline_data_addr(ipage);
309
310 make_dentry_ptr(NULL, &d, (void *)inline_dentry, 2);
311 de = find_target_dentry(fname, namehash, NULL, &d);
312 unlock_page(ipage);
313 if (de)
314 *res_page = ipage;
315 else
316 f2fs_put_page(ipage, 0);
317
318
319
320
321
322 f2fs_bug_on(sbi, d.max < 0);
323 return de;
324}
325
326struct f2fs_dir_entry *f2fs_parent_inline_dir(struct inode *dir,
327 struct page **p)
328{
329 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
330 struct page *ipage;
331 struct f2fs_dir_entry *de;
332 struct f2fs_inline_dentry *dentry_blk;
333
334 ipage = get_node_page(sbi, dir->i_ino);
335 if (IS_ERR(ipage))
336 return NULL;
337
338 dentry_blk = inline_data_addr(ipage);
339 de = &dentry_blk->dentry[1];
340 *p = ipage;
341 unlock_page(ipage);
342 return de;
343}
344
345int make_empty_inline_dir(struct inode *inode, struct inode *parent,
346 struct page *ipage)
347{
348 struct f2fs_inline_dentry *dentry_blk;
349 struct f2fs_dentry_ptr d;
350
351 dentry_blk = inline_data_addr(ipage);
352
353 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
354 do_make_empty_dir(inode, parent, &d);
355
356 set_page_dirty(ipage);
357
358
359 if (i_size_read(inode) < MAX_INLINE_DATA) {
360 i_size_write(inode, MAX_INLINE_DATA);
361 set_inode_flag(F2FS_I(inode), FI_UPDATE_DIR);
362 }
363 return 0;
364}
365
366
367
368
369
370static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,
371 struct f2fs_inline_dentry *inline_dentry)
372{
373 struct page *page;
374 struct dnode_of_data dn;
375 struct f2fs_dentry_block *dentry_blk;
376 int err;
377
378 page = grab_cache_page(dir->i_mapping, 0);
379 if (!page) {
380 f2fs_put_page(ipage, 1);
381 return -ENOMEM;
382 }
383
384 set_new_dnode(&dn, dir, ipage, NULL, 0);
385 err = f2fs_reserve_block(&dn, 0);
386 if (err)
387 goto out;
388
389 f2fs_wait_on_page_writeback(page, DATA);
390 zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);
391
392 dentry_blk = kmap_atomic(page);
393
394
395 memcpy(dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap,
396 INLINE_DENTRY_BITMAP_SIZE);
397 memset(dentry_blk->dentry_bitmap + INLINE_DENTRY_BITMAP_SIZE, 0,
398 SIZE_OF_DENTRY_BITMAP - INLINE_DENTRY_BITMAP_SIZE);
399
400
401
402
403
404
405 memcpy(dentry_blk->dentry, inline_dentry->dentry,
406 sizeof(struct f2fs_dir_entry) * NR_INLINE_DENTRY);
407 memcpy(dentry_blk->filename, inline_dentry->filename,
408 NR_INLINE_DENTRY * F2FS_SLOT_LEN);
409
410 kunmap_atomic(dentry_blk);
411 SetPageUptodate(page);
412 set_page_dirty(page);
413
414
415 truncate_inline_inode(ipage, 0);
416
417 stat_dec_inline_dir(dir);
418 clear_inode_flag(F2FS_I(dir), FI_INLINE_DENTRY);
419
420 if (i_size_read(dir) < PAGE_CACHE_SIZE) {
421 i_size_write(dir, PAGE_CACHE_SIZE);
422 set_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
423 }
424
425 sync_inode_page(&dn);
426out:
427 f2fs_put_page(page, 1);
428 return err;
429}
430
431int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,
432 struct inode *inode, nid_t ino, umode_t mode)
433{
434 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
435 struct page *ipage;
436 unsigned int bit_pos;
437 f2fs_hash_t name_hash;
438 size_t namelen = name->len;
439 struct f2fs_inline_dentry *dentry_blk = NULL;
440 struct f2fs_dentry_ptr d;
441 int slots = GET_DENTRY_SLOTS(namelen);
442 struct page *page = NULL;
443 int err = 0;
444
445 ipage = get_node_page(sbi, dir->i_ino);
446 if (IS_ERR(ipage))
447 return PTR_ERR(ipage);
448
449 dentry_blk = inline_data_addr(ipage);
450 bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,
451 slots, NR_INLINE_DENTRY);
452 if (bit_pos >= NR_INLINE_DENTRY) {
453 err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);
454 if (err)
455 return err;
456 err = -EAGAIN;
457 goto out;
458 }
459
460 if (inode) {
461 down_write(&F2FS_I(inode)->i_sem);
462 page = init_inode_metadata(inode, dir, name, ipage);
463 if (IS_ERR(page)) {
464 err = PTR_ERR(page);
465 goto fail;
466 }
467 }
468
469 f2fs_wait_on_page_writeback(ipage, NODE);
470
471 name_hash = f2fs_dentry_hash(name);
472 make_dentry_ptr(NULL, &d, (void *)dentry_blk, 2);
473 f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);
474
475 set_page_dirty(ipage);
476
477
478 if (inode) {
479 F2FS_I(inode)->i_pino = dir->i_ino;
480 update_inode(inode, page);
481 f2fs_put_page(page, 1);
482 }
483
484 update_parent_metadata(dir, inode, 0);
485fail:
486 if (inode)
487 up_write(&F2FS_I(inode)->i_sem);
488
489 if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {
490 update_inode(dir, ipage);
491 clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);
492 }
493out:
494 f2fs_put_page(ipage, 1);
495 return err;
496}
497
498void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
499 struct inode *dir, struct inode *inode)
500{
501 struct f2fs_inline_dentry *inline_dentry;
502 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
503 unsigned int bit_pos;
504 int i;
505
506 lock_page(page);
507 f2fs_wait_on_page_writeback(page, NODE);
508
509 inline_dentry = inline_data_addr(page);
510 bit_pos = dentry - inline_dentry->dentry;
511 for (i = 0; i < slots; i++)
512 test_and_clear_bit_le(bit_pos + i,
513 &inline_dentry->dentry_bitmap);
514
515 set_page_dirty(page);
516
517 dir->i_ctime = dir->i_mtime = CURRENT_TIME;
518
519 if (inode)
520 f2fs_drop_nlink(dir, inode, page);
521
522 f2fs_put_page(page, 1);
523}
524
525bool f2fs_empty_inline_dir(struct inode *dir)
526{
527 struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
528 struct page *ipage;
529 unsigned int bit_pos = 2;
530 struct f2fs_inline_dentry *dentry_blk;
531
532 ipage = get_node_page(sbi, dir->i_ino);
533 if (IS_ERR(ipage))
534 return false;
535
536 dentry_blk = inline_data_addr(ipage);
537 bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
538 NR_INLINE_DENTRY,
539 bit_pos);
540
541 f2fs_put_page(ipage, 1);
542
543 if (bit_pos < NR_INLINE_DENTRY)
544 return false;
545
546 return true;
547}
548
549int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
550 struct f2fs_str *fstr)
551{
552 struct inode *inode = file_inode(file);
553 struct f2fs_inline_dentry *inline_dentry = NULL;
554 struct page *ipage = NULL;
555 struct f2fs_dentry_ptr d;
556
557 if (ctx->pos == NR_INLINE_DENTRY)
558 return 0;
559
560 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
561 if (IS_ERR(ipage))
562 return PTR_ERR(ipage);
563
564 inline_dentry = inline_data_addr(ipage);
565
566 make_dentry_ptr(inode, &d, (void *)inline_dentry, 2);
567
568 if (!f2fs_fill_dentries(ctx, &d, 0, fstr))
569 ctx->pos = NR_INLINE_DENTRY;
570
571 f2fs_put_page(ipage, 1);
572 return 0;
573}
574
575int f2fs_inline_data_fiemap(struct inode *inode,
576 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
577{
578 __u64 byteaddr, ilen;
579 __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
580 FIEMAP_EXTENT_LAST;
581 struct node_info ni;
582 struct page *ipage;
583 int err = 0;
584
585 ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino);
586 if (IS_ERR(ipage))
587 return PTR_ERR(ipage);
588
589 if (!f2fs_has_inline_data(inode)) {
590 err = -EAGAIN;
591 goto out;
592 }
593
594 ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode));
595 if (start >= ilen)
596 goto out;
597 if (start + len < ilen)
598 ilen = start + len;
599 ilen -= start;
600
601 get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);
602 byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
603 byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage);
604 err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
605out:
606 f2fs_put_page(ipage, 1);
607 return err;
608}
609
