1/*
2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
3 */
4
5#include <linux/time.h>
6#include "reiserfs.h"
7#include "acl.h"
8#include "xattr.h"
9#include <linux/uaccess.h>
10#include <linux/pagemap.h>
11#include <linux/swap.h>
12#include <linux/writeback.h>
13#include <linux/blkdev.h>
14#include <linux/buffer_head.h>
15#include <linux/quotaops.h>
16
17/*
18 * We pack the tails of files on file close, not at the time they are written.
19 * This implies an unnecessary copy of the tail and an unnecessary indirect item
20 * insertion/balancing, for files that are written in one write.
21 * It avoids unnecessary tail packings (balances) for files that are written in
22 * multiple writes and are small enough to have tails.
23 *
24 * file_release is called by the VFS layer when the file is closed.  If
25 * this is the last open file descriptor, and the file
26 * small enough to have a tail, and the tail is currently in an
27 * unformatted node, the tail is converted back into a direct item.
28 *
29 * We use reiserfs_truncate_file to pack the tail, since it already has
30 * all the conditions coded.
31 */
32static int reiserfs_file_release(struct inode *inode, struct file *filp)
33{
34
35	struct reiserfs_transaction_handle th;
36	int err;
37	int jbegin_failure = 0;
38
39	BUG_ON(!S_ISREG(inode->i_mode));
40
41	if (!atomic_dec_and_mutex_lock(&REISERFS_I(inode)->openers,
42				       &REISERFS_I(inode)->tailpack))
43		return 0;
44
45	/* fast out for when nothing needs to be done */
46	if ((!(REISERFS_I(inode)->i_flags & i_pack_on_close_mask) ||
47	     !tail_has_to_be_packed(inode)) &&
48	    REISERFS_I(inode)->i_prealloc_count <= 0) {
49		mutex_unlock(&REISERFS_I(inode)->tailpack);
50		return 0;
51	}
52
53	reiserfs_write_lock(inode->i_sb);
54	/*
55	 * freeing preallocation only involves relogging blocks that
56	 * are already in the current transaction.  preallocation gets
57	 * freed at the end of each transaction, so it is impossible for
58	 * us to log any additional blocks (including quota blocks)
59	 */
60	err = journal_begin(&th, inode->i_sb, 1);
61	if (err) {
62		/*
63		 * uh oh, we can't allow the inode to go away while there
64		 * is still preallocation blocks pending.  Try to join the
65		 * aborted transaction
66		 */
67		jbegin_failure = err;
68		err = journal_join_abort(&th, inode->i_sb);
69
70		if (err) {
71			/*
72			 * hmpf, our choices here aren't good.  We can pin
73			 * the inode which will disallow unmount from ever
74			 * happening, we can do nothing, which will corrupt
75			 * random memory on unmount, or we can forcibly
76			 * remove the file from the preallocation list, which
77			 * will leak blocks on disk.  Lets pin the inode
78			 * and let the admin know what is going on.
79			 */
80			igrab(inode);
81			reiserfs_warning(inode->i_sb, "clm-9001",
82					 "pinning inode %lu because the "
83					 "preallocation can't be freed",
84					 inode->i_ino);
85			goto out;
86		}
87	}
88	reiserfs_update_inode_transaction(inode);
89
90#ifdef REISERFS_PREALLOCATE
91	reiserfs_discard_prealloc(&th, inode);
92#endif
93	err = journal_end(&th);
94
95	/* copy back the error code from journal_begin */
96	if (!err)
97		err = jbegin_failure;
98
99	if (!err &&
100	    (REISERFS_I(inode)->i_flags & i_pack_on_close_mask) &&
101	    tail_has_to_be_packed(inode)) {
102
103		/*
104		 * if regular file is released by last holder and it has been
105		 * appended (we append by unformatted node only) or its direct
106		 * item(s) had to be converted, then it may have to be
107		 * indirect2direct converted
108		 */
109		err = reiserfs_truncate_file(inode, 0);
110	}
111out:
112	reiserfs_write_unlock(inode->i_sb);
113	mutex_unlock(&REISERFS_I(inode)->tailpack);
114	return err;
115}
116
117static int reiserfs_file_open(struct inode *inode, struct file *file)
118{
119	int err = dquot_file_open(inode, file);
120
121	/* somebody might be tailpacking on final close; wait for it */
122        if (!atomic_inc_not_zero(&REISERFS_I(inode)->openers)) {
123		mutex_lock(&REISERFS_I(inode)->tailpack);
124		atomic_inc(&REISERFS_I(inode)->openers);
125		mutex_unlock(&REISERFS_I(inode)->tailpack);
126	}
127	return err;
128}
129
130void reiserfs_vfs_truncate_file(struct inode *inode)
131{
132	mutex_lock(&REISERFS_I(inode)->tailpack);
133	reiserfs_truncate_file(inode, 1);
134	mutex_unlock(&REISERFS_I(inode)->tailpack);
135}
136
137/* Sync a reiserfs file. */
138
139/*
140 * FIXME: sync_mapping_buffers() never has anything to sync.  Can
141 * be removed...
142 */
143
144static int reiserfs_sync_file(struct file *filp, loff_t start, loff_t end,
145			      int datasync)
146{
147	struct inode *inode = filp->f_mapping->host;
148	int err;
149	int barrier_done;
150
151	err = file_write_and_wait_range(filp, start, end);
152	if (err)
153		return err;
154
155	inode_lock(inode);
156	BUG_ON(!S_ISREG(inode->i_mode));
157	err = sync_mapping_buffers(inode->i_mapping);
158	reiserfs_write_lock(inode->i_sb);
159	barrier_done = reiserfs_commit_for_inode(inode);
160	reiserfs_write_unlock(inode->i_sb);
161	if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
162		blkdev_issue_flush(inode->i_sb->s_bdev);
163	inode_unlock(inode);
164	if (barrier_done < 0)
165		return barrier_done;
166	return (err < 0) ? -EIO : 0;
167}
168
169/* taken fs/buffer.c:__block_commit_write */
170int reiserfs_commit_page(struct inode *inode, struct page *page,
171			 unsigned from, unsigned to)
172{
173	unsigned block_start, block_end;
174	int partial = 0;
175	unsigned blocksize;
176	struct buffer_head *bh, *head;
177	unsigned long i_size_index = inode->i_size >> PAGE_SHIFT;
178	int new;
179	int logit = reiserfs_file_data_log(inode);
180	struct super_block *s = inode->i_sb;
181	int bh_per_page = PAGE_SIZE / s->s_blocksize;
182	struct reiserfs_transaction_handle th;
183	int ret = 0;
184
185	th.t_trans_id = 0;
186	blocksize = i_blocksize(inode);
187
188	if (logit) {
189		reiserfs_write_lock(s);
190		ret = journal_begin(&th, s, bh_per_page + 1);
191		if (ret)
192			goto drop_write_lock;
193		reiserfs_update_inode_transaction(inode);
194	}
195	for (bh = head = page_buffers(page), block_start = 0;
196	     bh != head || !block_start;
197	     block_start = block_end, bh = bh->b_this_page) {
198
199		new = buffer_new(bh);
200		clear_buffer_new(bh);
201		block_end = block_start + blocksize;
202		if (block_end <= from || block_start >= to) {
203			if (!buffer_uptodate(bh))
204				partial = 1;
205		} else {
206			set_buffer_uptodate(bh);
207			if (logit) {
208				reiserfs_prepare_for_journal(s, bh, 1);
209				journal_mark_dirty(&th, bh);
210			} else if (!buffer_dirty(bh)) {
211				mark_buffer_dirty(bh);
212				/*
213				 * do data=ordered on any page past the end
214				 * of file and any buffer marked BH_New.
215				 */
216				if (reiserfs_data_ordered(inode->i_sb) &&
217				    (new || page->index >= i_size_index)) {
218					reiserfs_add_ordered_list(inode, bh);
219				}
220			}
221		}
222	}
223	if (logit) {
224		ret = journal_end(&th);
225drop_write_lock:
226		reiserfs_write_unlock(s);
227	}
228	/*
229	 * If this is a partial write which happened to make all buffers
230	 * uptodate then we can optimize away a bogus read_folio() for
231	 * the next read(). Here we 'discover' whether the page went
232	 * uptodate as a result of this (potentially partial) write.
233	 */
234	if (!partial)
235		SetPageUptodate(page);
236	return ret;
237}
238
239const struct file_operations reiserfs_file_operations = {
240	.unlocked_ioctl = reiserfs_ioctl,
241#ifdef CONFIG_COMPAT
242	.compat_ioctl = reiserfs_compat_ioctl,
243#endif
244	.mmap = generic_file_mmap,
245	.open = reiserfs_file_open,
246	.release = reiserfs_file_release,
247	.fsync = reiserfs_sync_file,
248	.read_iter = generic_file_read_iter,
249	.write_iter = generic_file_write_iter,
250	.splice_read = filemap_splice_read,
251	.splice_write = iter_file_splice_write,
252	.llseek = generic_file_llseek,
253};
254
255const struct inode_operations reiserfs_file_inode_operations = {
256	.setattr = reiserfs_setattr,
257	.listxattr = reiserfs_listxattr,
258	.permission = reiserfs_permission,
259	.get_inode_acl = reiserfs_get_acl,
260	.set_acl = reiserfs_set_acl,
261	.fileattr_get = reiserfs_fileattr_get,
262	.fileattr_set = reiserfs_fileattr_set,
263};
264
265const struct inode_operations reiserfs_priv_file_inode_operations = {
266	.setattr = reiserfs_setattr,
267	.permission = reiserfs_permission,
268	.fileattr_get = reiserfs_fileattr_get,
269	.fileattr_set = reiserfs_fileattr_set,
270};
271