1/*
2 *  file.c
3 *
4 *  Copyright (C) 1995, 1996, 1997 by Paal-Kr. Engstad and Volker Lendecke
5 *  Copyright (C) 1997 by Volker Lendecke
6 *
7 *  Please add a note about your changes to smbfs in the ChangeLog file.
8 */
9
10#include <linux/time.h>
11#include <linux/kernel.h>
12#include <linux/errno.h>
13#include <linux/fcntl.h>
14#include <linux/stat.h>
15#include <linux/mm.h>
16#include <linux/slab.h>
17#include <linux/pagemap.h>
18#include <linux/smp_lock.h>
19#include <linux/net.h>
20#include <linux/aio.h>
21
22#include <asm/uaccess.h>
23#include <asm/system.h>
24
25#include <linux/smbno.h>
26#include <linux/smb_fs.h>
27
28#include "smb_debug.h"
29#include "proto.h"
30
31static int
32smb_fsync(struct file *file, struct dentry * dentry, int datasync)
33{
34	struct smb_sb_info *server = server_from_dentry(dentry);
35	int result;
36
37	VERBOSE("sync file %s/%s\n", DENTRY_PATH(dentry));
38
39	/*
40	 * The VFS will writepage() all dirty pages for us, but we
41	 * should send a SMBflush to the server, letting it know that
42	 * we want things synchronized with actual storage.
43	 *
44	 * Note: this function requires all pages to have been written already
45	 *       (should be ok with writepage_sync)
46	 */
47	result = smb_proc_flush(server, SMB_I(dentry->d_inode)->fileid);
48	return result;
49}
50
51/*
52 * Read a page synchronously.
53 */
54static int
55smb_readpage_sync(struct dentry *dentry, struct page *page)
56{
57	char *buffer = kmap(page);
58	loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
59	struct smb_sb_info *server = server_from_dentry(dentry);
60	unsigned int rsize = smb_get_rsize(server);
61	int count = PAGE_SIZE;
62	int result;
63
64	VERBOSE("file %s/%s, count=%d@%Ld, rsize=%d\n",
65		DENTRY_PATH(dentry), count, offset, rsize);
66
67	result = smb_open(dentry, SMB_O_RDONLY);
68	if (result < 0)
69		goto io_error;
70
71	do {
72		if (count < rsize)
73			rsize = count;
74
75		result = server->ops->read(dentry->d_inode,offset,rsize,buffer);
76		if (result < 0)
77			goto io_error;
78
79		count -= result;
80		offset += result;
81		buffer += result;
82		dentry->d_inode->i_atime =
83			current_fs_time(dentry->d_inode->i_sb);
84		if (result < rsize)
85			break;
86	} while (count);
87
88	memset(buffer, 0, count);
89	flush_dcache_page(page);
90	SetPageUptodate(page);
91	result = 0;
92
93io_error:
94	kunmap(page);
95	unlock_page(page);
96	return result;
97}
98
99/*
100 * We are called with the page locked and we unlock it when done.
101 */
102static int
103smb_readpage(struct file *file, struct page *page)
104{
105	int		error;
106	struct dentry  *dentry = file->f_path.dentry;
107
108	page_cache_get(page);
109	error = smb_readpage_sync(dentry, page);
110	page_cache_release(page);
111	return error;
112}
113
114/*
115 * Write a page synchronously.
116 * Offset is the data offset within the page.
117 */
118static int
119smb_writepage_sync(struct inode *inode, struct page *page,
120		   unsigned long pageoffset, unsigned int count)
121{
122	loff_t offset;
123	char *buffer = kmap(page) + pageoffset;
124	struct smb_sb_info *server = server_from_inode(inode);
125	unsigned int wsize = smb_get_wsize(server);
126	int ret = 0;
127
128	offset = ((loff_t)page->index << PAGE_CACHE_SHIFT) + pageoffset;
129	VERBOSE("file ino=%ld, fileid=%d, count=%d@%Ld, wsize=%d\n",
130		inode->i_ino, SMB_I(inode)->fileid, count, offset, wsize);
131
132	do {
133		int write_ret;
134
135		if (count < wsize)
136			wsize = count;
137
138		write_ret = server->ops->write(inode, offset, wsize, buffer);
139		if (write_ret < 0) {
140			PARANOIA("failed write, wsize=%d, write_ret=%d\n",
141				 wsize, write_ret);
142			ret = write_ret;
143			break;
144		}
145		/* N.B. what if result < wsize?? */
146#ifdef SMBFS_PARANOIA
147		if (write_ret < wsize)
148			PARANOIA("short write, wsize=%d, write_ret=%d\n",
149				 wsize, write_ret);
150#endif
151		buffer += wsize;
152		offset += wsize;
153		count -= wsize;
154		/*
155		 * Update the inode now rather than waiting for a refresh.
156		 */
157		inode->i_mtime = inode->i_atime = current_fs_time(inode->i_sb);
158		SMB_I(inode)->flags |= SMB_F_LOCALWRITE;
159		if (offset > inode->i_size)
160			inode->i_size = offset;
161	} while (count);
162
163	kunmap(page);
164	return ret;
165}
166
167/*
168 * Write a page to the server. This will be used for NFS swapping only
169 * (for now), and we currently do this synchronously only.
170 *
171 * We are called with the page locked and we unlock it when done.
172 */
173static int
174smb_writepage(struct page *page, struct writeback_control *wbc)
175{
176	struct address_space *mapping = page->mapping;
177	struct inode *inode;
178	unsigned long end_index;
179	unsigned offset = PAGE_CACHE_SIZE;
180	int err;
181
182	BUG_ON(!mapping);
183	inode = mapping->host;
184	BUG_ON(!inode);
185
186	end_index = inode->i_size >> PAGE_CACHE_SHIFT;
187
188	/* easy case */
189	if (page->index < end_index)
190		goto do_it;
191	/* things got complicated... */
192	offset = inode->i_size & (PAGE_CACHE_SIZE-1);
193	/* OK, are we completely out? */
194	if (page->index >= end_index+1 || !offset)
195		return 0; /* truncated - don't care */
196do_it:
197	page_cache_get(page);
198	err = smb_writepage_sync(inode, page, 0, offset);
199	SetPageUptodate(page);
200	unlock_page(page);
201	page_cache_release(page);
202	return err;
203}
204
205static int
206smb_updatepage(struct file *file, struct page *page, unsigned long offset,
207	       unsigned int count)
208{
209	struct dentry *dentry = file->f_path.dentry;
210
211	DEBUG1("(%s/%s %d@%lld)\n", DENTRY_PATH(dentry), count,
212		((unsigned long long)page->index << PAGE_CACHE_SHIFT) + offset);
213
214	return smb_writepage_sync(dentry->d_inode, page, offset, count);
215}
216
217static ssize_t
218smb_file_aio_read(struct kiocb *iocb, const struct iovec *iov,
219			unsigned long nr_segs, loff_t pos)
220{
221	struct file * file = iocb->ki_filp;
222	struct dentry * dentry = file->f_path.dentry;
223	ssize_t	status;
224
225	VERBOSE("file %s/%s, count=%lu@%lu\n", DENTRY_PATH(dentry),
226		(unsigned long) iocb->ki_left, (unsigned long) pos);
227
228	status = smb_revalidate_inode(dentry);
229	if (status) {
230		PARANOIA("%s/%s validation failed, error=%Zd\n",
231			 DENTRY_PATH(dentry), status);
232		goto out;
233	}
234
235	VERBOSE("before read, size=%ld, flags=%x, atime=%ld\n",
236		(long)dentry->d_inode->i_size,
237		dentry->d_inode->i_flags, dentry->d_inode->i_atime);
238
239	status = generic_file_aio_read(iocb, iov, nr_segs, pos);
240out:
241	return status;
242}
243
244static int
245smb_file_mmap(struct file * file, struct vm_area_struct * vma)
246{
247	struct dentry * dentry = file->f_path.dentry;
248	int	status;
249
250	VERBOSE("file %s/%s, address %lu - %lu\n",
251		DENTRY_PATH(dentry), vma->vm_start, vma->vm_end);
252
253	status = smb_revalidate_inode(dentry);
254	if (status) {
255		PARANOIA("%s/%s validation failed, error=%d\n",
256			 DENTRY_PATH(dentry), status);
257		goto out;
258	}
259	status = generic_file_mmap(file, vma);
260out:
261	return status;
262}
263
264static ssize_t
265smb_file_sendfile(struct file *file, loff_t *ppos,
266		  size_t count, read_actor_t actor, void *target)
267{
268	struct dentry *dentry = file->f_path.dentry;
269	ssize_t status;
270
271	VERBOSE("file %s/%s, pos=%Ld, count=%d\n",
272		DENTRY_PATH(dentry), *ppos, count);
273
274	status = smb_revalidate_inode(dentry);
275	if (status) {
276		PARANOIA("%s/%s validation failed, error=%Zd\n",
277			 DENTRY_PATH(dentry), status);
278		goto out;
279	}
280	status = generic_file_sendfile(file, ppos, count, actor, target);
281out:
282	return status;
283}
284
285/*
286 * This does the "real" work of the write. The generic routine has
287 * allocated the page, locked it, done all the page alignment stuff
288 * calculations etc. Now we should just copy the data from user
289 * space and write it back to the real medium..
290 *
291 * If the writer ends up delaying the write, the writer needs to
292 * increment the page use counts until he is done with the page.
293 */
294static int smb_prepare_write(struct file *file, struct page *page,
295			     unsigned offset, unsigned to)
296{
297	return 0;
298}
299
300static int smb_commit_write(struct file *file, struct page *page,
301			    unsigned offset, unsigned to)
302{
303	int status;
304
305	status = -EFAULT;
306	lock_kernel();
307	status = smb_updatepage(file, page, offset, to-offset);
308	unlock_kernel();
309	return status;
310}
311
312const struct address_space_operations smb_file_aops = {
313	.readpage = smb_readpage,
314	.writepage = smb_writepage,
315	.prepare_write = smb_prepare_write,
316	.commit_write = smb_commit_write
317};
318
319/*
320 * Write to a file (through the page cache).
321 */
322static ssize_t
323smb_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
324			       unsigned long nr_segs, loff_t pos)
325{
326	struct file * file = iocb->ki_filp;
327	struct dentry * dentry = file->f_path.dentry;
328	ssize_t	result;
329
330	VERBOSE("file %s/%s, count=%lu@%lu\n",
331		DENTRY_PATH(dentry),
332		(unsigned long) iocb->ki_left, (unsigned long) pos);
333
334	result = smb_revalidate_inode(dentry);
335	if (result) {
336		PARANOIA("%s/%s validation failed, error=%Zd\n",
337			 DENTRY_PATH(dentry), result);
338		goto out;
339	}
340
341	result = smb_open(dentry, SMB_O_WRONLY);
342	if (result)
343		goto out;
344
345	if (iocb->ki_left > 0) {
346		result = generic_file_aio_write(iocb, iov, nr_segs, pos);
347		VERBOSE("pos=%ld, size=%ld, mtime=%ld, atime=%ld\n",
348			(long) file->f_pos, (long) dentry->d_inode->i_size,
349			dentry->d_inode->i_mtime, dentry->d_inode->i_atime);
350	}
351out:
352	return result;
353}
354
355static int
356smb_file_open(struct inode *inode, struct file * file)
357{
358	int result;
359	struct dentry *dentry = file->f_path.dentry;
360	int smb_mode = (file->f_mode & O_ACCMODE) - 1;
361
362	lock_kernel();
363	result = smb_open(dentry, smb_mode);
364	if (result)
365		goto out;
366	SMB_I(inode)->openers++;
367out:
368	unlock_kernel();
369	return result;
370}
371
372static int
373smb_file_release(struct inode *inode, struct file * file)
374{
375	lock_kernel();
376	if (!--SMB_I(inode)->openers) {
377		/* We must flush any dirty pages now as we won't be able to
378		   write anything after close. mmap can trigger this.
379		   "openers" should perhaps include mmap'ers ... */
380		filemap_write_and_wait(inode->i_mapping);
381		smb_close(inode);
382	}
383	unlock_kernel();
384	return 0;
385}
386
387/*
388 * Check whether the required access is compatible with
389 * an inode's permission. SMB doesn't recognize superuser
390 * privileges, so we need our own check for this.
391 */
392static int
393smb_file_permission(struct inode *inode, int mask, struct nameidata *nd)
394{
395	int mode = inode->i_mode;
396	int error = 0;
397
398	VERBOSE("mode=%x, mask=%x\n", mode, mask);
399
400	/* Look at user permissions */
401	mode >>= 6;
402	if ((mode & 7 & mask) != mask)
403		error = -EACCES;
404	return error;
405}
406
407const struct file_operations smb_file_operations =
408{
409	.llseek		= remote_llseek,
410	.read		= do_sync_read,
411	.aio_read	= smb_file_aio_read,
412	.write		= do_sync_write,
413	.aio_write	= smb_file_aio_write,
414	.ioctl		= smb_ioctl,
415	.mmap		= smb_file_mmap,
416	.open		= smb_file_open,
417	.release	= smb_file_release,
418	.fsync		= smb_fsync,
419	.sendfile	= smb_file_sendfile,
420};
421
422const struct inode_operations smb_file_inode_operations =
423{
424	.permission	= smb_file_permission,
425	.getattr	= smb_getattr,
426	.setattr	= smb_notify_change,
427};
428