linux-stable.git/fs/f2fs/data.c, branch v3.19

f2fs: fix to return correct error number in f2fs_write_begin

2014-12-01T21:56:02+00:00

Fix the wrong error number in error path of f2fs_write_begin.

Signed-off-by: Chao Yu 
Signed-off-by: Jaegeuk Kim

f2fs: fix deadlock during inline_data conversion

2014-11-25T20:08:30+00:00

A deadlock can be occurred:
Thread 1]                             Thread 2]
 - f2fs_write_data_pages              - f2fs_write_begin
   - lock_page(page #0)
                                        - grab_cache_page(page #X)
                                        - get_node_page(inode_page)
                                        - grab_cache_page(page #0)
                                          : to convert inline_data
   - f2fs_write_data_page
     - f2fs_write_inline_data
       - get_node_page(inode_page)

In this case, trying to lock inode_page and page #0 causes deadlock.
In order to avoid this, this patch adds a rule for this locking policy,
which is that page #0 should be locked followed by inode_page lock.

Signed-off-by: Jaegeuk Kim

f2fs: put the inode page when error was occurred

2014-11-19T01:04:33+00:00

We should put the inode page when error was occurred.

Signed-off-by: Jaegeuk Kim

f2fs: avoid race condition in handling wait_io

2014-11-05T01:34:14+00:00

__submit_merged_bio    f2fs_write_end_io        f2fs_write_end_io
                       wait_io = X              wait_io = x
                       complete(X)              complete(X)
                       wait_io = NULL
wait_for_completion()
free(X)
                                                 spin_lock(X)
                                                 kernel panic

In order to avoid this, this patch removes the wait_io facility.
Instead, we can use wait_on_all_pages_writeback(sbi) to wait for end_ios.

Signed-off-by: Jaegeuk Kim

f2fs: revisit inline_data to avoid data races and potential bugs

2014-11-05T01:34:11+00:00

This patch simplifies the inline_data usage with the following rule.
1. inline_data is set during the file creation.
2. If new data is requested to be written ranges out of inline_data,
 f2fs converts that inode permanently.
3. There is no cases which converts non-inline_data inode to inline_data.
4. The inline_data flag should be changed under inode page lock.

Signed-off-by: Jaegeuk Kim

f2fs: fix possible data corruption in f2fs_write_begin()

2014-11-04T00:07:37+00:00

f2fs_write_begin() doesn't initialize the 'dn' variable if the inode has
inline data. However it uses its contents to decide whether it should
just zero out the page or load data to it. Thus if we are unlucky we can
zero out page contents instead of loading inline data into a page.

CC: stable@vger.kernel.org
CC: Changman Lee 
Signed-off-by: Jan Kara 
Signed-off-by: Jaegeuk Kim

f2fs: avoid to allocate when inline_data was written

2014-11-04T00:07:30+00:00

The sceanrio is like this.
inline_data   i_size     page                 write_begin/vm_page_mkwrite
  X             30       dirty_page
  X             30                            write to #4096 position
  X             30       get_dnode_of_data    wait for get_dnode_of_data
  O             30       write inline_data
  O             30                            get_dnode_of_data
  O             30                            reserve data block
..

In this case, we have #0 = NEW_ADDR and inline_data as well.
We should not allow this condition for further access.

Signed-off-by: Jaegeuk Kim

f2fs: invalidate inmemory page

2014-11-04T00:07:29+00:00

If user truncates file's data, we should truncate inmemory pages too.

Signed-off-by: Jaegeuk Kim

f2fs: do not make dirty any inmemory pages

2014-11-04T00:07:29+00:00

This patch let inmemory pages be clean all the time.

Signed-off-by: Jaegeuk Kim

f2fs: support volatile operations for transient data

2014-10-07T18:54:41+00:00

This patch adds support for volatile writes which keep data pages in memory
until f2fs_evict_inode is called by iput.

For instance, we can use this feature for the sqlite database as follows.
While supporting atomic writes for main database file, we can keep its journal
data temporarily in the page cache by the following sequence.

1. open
 -> ioctl(F2FS_IOC_START_VOLATILE_WRITE);
2. writes
 : keep all the data in the page cache.
3. flush to the database file with atomic writes
  a. ioctl(F2FS_IOC_START_ATOMIC_WRITE);
  b. writes
  c. ioctl(F2FS_IOC_COMMIT_ATOMIC_WRITE);
4. close
 -> drop the cached data

Signed-off-by: Jaegeuk Kim