file.c 6.42 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
/*
 *  file.c
 *
 *  Copyright (C) 1995, 1996 by Volker Lendecke
 *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
 *
 */

9
10
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
14
15
16
17
18
19
#include <asm/uaccess.h>

#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/mm.h>
#include <linux/vmalloc.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
20
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
21

22
#include "ncp_fs.h"
Linus Torvalds's avatar
Linus Torvalds committed
23

24
static int ncp_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Linus Torvalds's avatar
Linus Torvalds committed
25
{
26
	return filemap_write_and_wait_range(file->f_mapping, start, end);
Linus Torvalds's avatar
Linus Torvalds committed
27
28
29
30
31
32
33
34
35
36
37
38
}

/*
 * Open a file with the specified read/write mode.
 */
int ncp_make_open(struct inode *inode, int right)
{
	int error;
	int access;

	error = -EINVAL;
	if (!inode) {
39
		pr_err("%s: got NULL inode\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
40
41
42
		goto out;
	}

43
	ncp_dbg(1, "opened=%d, volume # %u, dir entry # %u\n",
Linus Torvalds's avatar
Linus Torvalds committed
44
45
46
47
		atomic_read(&NCP_FINFO(inode)->opened), 
		NCP_FINFO(inode)->volNumber, 
		NCP_FINFO(inode)->dirEntNum);
	error = -EACCES;
Ingo Molnar's avatar
Ingo Molnar committed
48
	mutex_lock(&NCP_FINFO(inode)->open_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
	if (!atomic_read(&NCP_FINFO(inode)->opened)) {
		struct ncp_entry_info finfo;
		int result;

		/* tries max. rights */
		finfo.access = O_RDWR;
		result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
					inode, NULL, OC_MODE_OPEN,
					0, AR_READ | AR_WRITE, &finfo);
		if (!result)
			goto update;
		/* RDWR did not succeeded, try readonly or writeonly as requested */
		switch (right) {
			case O_RDONLY:
				finfo.access = O_RDONLY;
				result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
					inode, NULL, OC_MODE_OPEN,
					0, AR_READ, &finfo);
				break;
			case O_WRONLY:
				finfo.access = O_WRONLY;
				result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
					inode, NULL, OC_MODE_OPEN,
					0, AR_WRITE, &finfo);
				break;
		}
		if (result) {
76
			ncp_vdbg("failed, result=%d\n", result);
Linus Torvalds's avatar
Linus Torvalds committed
77
78
79
80
81
82
83
84
85
86
87
			goto out_unlock;
		}
		/*
		 * Update the inode information.
		 */
	update:
		ncp_update_inode(inode, &finfo);
		atomic_set(&NCP_FINFO(inode)->opened, 1);
	}

	access = NCP_FINFO(inode)->access;
88
	ncp_vdbg("file open, access=%x\n", access);
Linus Torvalds's avatar
Linus Torvalds committed
89
90
91
92
93
94
	if (access == right || access == O_RDWR) {
		atomic_inc(&NCP_FINFO(inode)->opened);
		error = 0;
	}

out_unlock:
Ingo Molnar's avatar
Ingo Molnar committed
95
	mutex_unlock(&NCP_FINFO(inode)->open_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
96
97
98
99
100
101
102
out:
	return error;
}

static ssize_t
ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
103
	struct dentry *dentry = file->f_path.dentry;
Linus Torvalds's avatar
Linus Torvalds committed
104
105
106
107
108
109
110
111
	struct inode *inode = dentry->d_inode;
	size_t already_read = 0;
	off_t pos;
	size_t bufsize;
	int error;
	void* freepage;
	size_t freelen;

112
	ncp_dbg(1, "enter %pd2\n", dentry);
Linus Torvalds's avatar
Linus Torvalds committed
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

	pos = *ppos;

	if ((ssize_t) count < 0) {
		return -EINVAL;
	}
	if (!count)
		return 0;
	if (pos > inode->i_sb->s_maxbytes)
		return 0;
	if (pos + count > inode->i_sb->s_maxbytes) {
		count = inode->i_sb->s_maxbytes - pos;
	}

	error = ncp_make_open(inode, O_RDONLY);
	if (error) {
129
		ncp_dbg(1, "open failed, error=%d\n", error);
Linus Torvalds's avatar
Linus Torvalds committed
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
		return error;
	}

	bufsize = NCP_SERVER(inode)->buffer_size;

	error = -EIO;
	freelen = ncp_read_bounce_size(bufsize);
	freepage = vmalloc(freelen);
	if (!freepage)
		goto outrel;
	error = 0;
	/* First read in as much as possible for each bufsize. */
	while (already_read < count) {
		int read_this_time;
		size_t to_read = min_t(unsigned int,
				     bufsize - (pos % bufsize),
				     count - already_read);

		error = ncp_read_bounce(NCP_SERVER(inode),
			 	NCP_FINFO(inode)->file_handle,
				pos, to_read, buf, &read_this_time, 
				freepage, freelen);
		if (error) {
			error = -EIO;	/* NW errno -> Linux errno */
			break;
		}
		pos += read_this_time;
		buf += read_this_time;
		already_read += read_this_time;

		if (read_this_time != to_read) {
			break;
		}
	}
	vfree(freepage);

	*ppos = pos;

	file_accessed(file);

170
	ncp_dbg(1, "exit %pd2\n", dentry);
Linus Torvalds's avatar
Linus Torvalds committed
171
172
173
174
175
176
177
178
outrel:
	ncp_inode_close(inode);		
	return already_read ? already_read : error;
}

static ssize_t
ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
179
	struct dentry *dentry = file->f_path.dentry;
Linus Torvalds's avatar
Linus Torvalds committed
180
181
182
183
184
185
186
	struct inode *inode = dentry->d_inode;
	size_t already_written = 0;
	off_t pos;
	size_t bufsize;
	int errno;
	void* bouncebuffer;

187
	ncp_dbg(1, "enter %pd2\n", dentry);
Linus Torvalds's avatar
Linus Torvalds committed
188
189
190
191
	if ((ssize_t) count < 0)
		return -EINVAL;
	pos = *ppos;
	if (file->f_flags & O_APPEND) {
Petr Vandrovec's avatar
Petr Vandrovec committed
192
		pos = i_size_read(inode);
Linus Torvalds's avatar
Linus Torvalds committed
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
	}

	if (pos + count > MAX_NON_LFS && !(file->f_flags&O_LARGEFILE)) {
		if (pos >= MAX_NON_LFS) {
			return -EFBIG;
		}
		if (count > MAX_NON_LFS - (u32)pos) {
			count = MAX_NON_LFS - (u32)pos;
		}
	}
	if (pos >= inode->i_sb->s_maxbytes) {
		if (count || pos > inode->i_sb->s_maxbytes) {
			return -EFBIG;
		}
	}
	if (pos + count > inode->i_sb->s_maxbytes) {
		count = inode->i_sb->s_maxbytes - pos;
	}
	
	if (!count)
		return 0;
	errno = ncp_make_open(inode, O_WRONLY);
	if (errno) {
216
		ncp_dbg(1, "open failed, error=%d\n", errno);
Linus Torvalds's avatar
Linus Torvalds committed
217
218
219
220
221
222
		return errno;
	}
	bufsize = NCP_SERVER(inode)->buffer_size;

	already_written = 0;

223
224
225
226
	errno = file_update_time(file);
	if (errno)
		goto outrel;

Linus Torvalds's avatar
Linus Torvalds committed
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
	bouncebuffer = vmalloc(bufsize);
	if (!bouncebuffer) {
		errno = -EIO;	/* -ENOMEM */
		goto outrel;
	}
	while (already_written < count) {
		int written_this_time;
		size_t to_write = min_t(unsigned int,
				      bufsize - (pos % bufsize),
				      count - already_written);

		if (copy_from_user(bouncebuffer, buf, to_write)) {
			errno = -EFAULT;
			break;
		}
		if (ncp_write_kernel(NCP_SERVER(inode), 
		    NCP_FINFO(inode)->file_handle,
		    pos, to_write, bouncebuffer, &written_this_time) != 0) {
			errno = -EIO;
			break;
		}
		pos += written_this_time;
		buf += written_this_time;
		already_written += written_this_time;

		if (written_this_time != to_write) {
			break;
		}
	}
	vfree(bouncebuffer);

	*ppos = pos;

Petr Vandrovec's avatar
Petr Vandrovec committed
260
261
262
263
264
	if (pos > i_size_read(inode)) {
		mutex_lock(&inode->i_mutex);
		if (pos > i_size_read(inode))
			i_size_write(inode, pos);
		mutex_unlock(&inode->i_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
265
	}
266
	ncp_dbg(1, "exit %pd2\n", dentry);
Linus Torvalds's avatar
Linus Torvalds committed
267
268
269
270
271
272
273
outrel:
	ncp_inode_close(inode);		
	return already_written ? already_written : errno;
}

static int ncp_release(struct inode *inode, struct file *file) {
	if (ncp_make_closed(inode)) {
274
		ncp_dbg(1, "failed to close\n");
Linus Torvalds's avatar
Linus Torvalds committed
275
276
277
278
	}
	return 0;
}

279
const struct file_operations ncp_file_operations =
Linus Torvalds's avatar
Linus Torvalds committed
280
{
Petr Vandrovec's avatar
Petr Vandrovec committed
281
	.llseek		= generic_file_llseek,
Linus Torvalds's avatar
Linus Torvalds committed
282
283
	.read		= ncp_file_read,
	.write		= ncp_file_write,
John Kacur's avatar
John Kacur committed
284
	.unlocked_ioctl	= ncp_ioctl,
285
286
287
#ifdef CONFIG_COMPAT
	.compat_ioctl	= ncp_compat_ioctl,
#endif
Linus Torvalds's avatar
Linus Torvalds committed
288
289
290
291
292
	.mmap		= ncp_mmap,
	.release	= ncp_release,
	.fsync		= ncp_fsync,
};

293
const struct inode_operations ncp_file_inode_operations =
Linus Torvalds's avatar
Linus Torvalds committed
294
295
296
{
	.setattr	= ncp_notify_change,
};