1 /*
2  *  file.c
3  *
4  *  Copyright (C) 1995, 1996 by Volker Lendecke
5  *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
6  *
7  */
8 
9 #include <asm/uaccess.h>
10 #include <asm/system.h>
11 
12 #include <linux/time.h>
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/fcntl.h>
16 #include <linux/stat.h>
17 #include <linux/mm.h>
18 #include <linux/vmalloc.h>
19 #include <linux/sched.h>
20 
21 #include "ncp_fs.h"
22 
ncp_fsync(struct file * file,loff_t start,loff_t end,int datasync)23 static int ncp_fsync(struct file *file, loff_t start, loff_t end, int datasync)
24 {
25 	return filemap_write_and_wait_range(file->f_mapping, start, end);
26 }
27 
28 /*
29  * Open a file with the specified read/write mode.
30  */
ncp_make_open(struct inode * inode,int right)31 int ncp_make_open(struct inode *inode, int right)
32 {
33 	int error;
34 	int access;
35 
36 	error = -EINVAL;
37 	if (!inode) {
38 		printk(KERN_ERR "ncp_make_open: got NULL inode\n");
39 		goto out;
40 	}
41 
42 	DPRINTK("ncp_make_open: opened=%d, volume # %u, dir entry # %u\n",
43 		atomic_read(&NCP_FINFO(inode)->opened),
44 		NCP_FINFO(inode)->volNumber,
45 		NCP_FINFO(inode)->dirEntNum);
46 	error = -EACCES;
47 	mutex_lock(&NCP_FINFO(inode)->open_mutex);
48 	if (!atomic_read(&NCP_FINFO(inode)->opened)) {
49 		struct ncp_entry_info finfo;
50 		int result;
51 
52 		/* tries max. rights */
53 		finfo.access = O_RDWR;
54 		result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
55 					inode, NULL, OC_MODE_OPEN,
56 					0, AR_READ | AR_WRITE, &finfo);
57 		if (!result)
58 			goto update;
59 		/* RDWR did not succeeded, try readonly or writeonly as requested */
60 		switch (right) {
61 			case O_RDONLY:
62 				finfo.access = O_RDONLY;
63 				result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
64 					inode, NULL, OC_MODE_OPEN,
65 					0, AR_READ, &finfo);
66 				break;
67 			case O_WRONLY:
68 				finfo.access = O_WRONLY;
69 				result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
70 					inode, NULL, OC_MODE_OPEN,
71 					0, AR_WRITE, &finfo);
72 				break;
73 		}
74 		if (result) {
75 			PPRINTK("ncp_make_open: failed, result=%d\n", result);
76 			goto out_unlock;
77 		}
78 		/*
79 		 * Update the inode information.
80 		 */
81 	update:
82 		ncp_update_inode(inode, &finfo);
83 		atomic_set(&NCP_FINFO(inode)->opened, 1);
84 	}
85 
86 	access = NCP_FINFO(inode)->access;
87 	PPRINTK("ncp_make_open: file open, access=%x\n", access);
88 	if (access == right || access == O_RDWR) {
89 		atomic_inc(&NCP_FINFO(inode)->opened);
90 		error = 0;
91 	}
92 
93 out_unlock:
94 	mutex_unlock(&NCP_FINFO(inode)->open_mutex);
95 out:
96 	return error;
97 }
98 
99 static ssize_t
ncp_file_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)100 ncp_file_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
101 {
102 	struct dentry *dentry = file->f_path.dentry;
103 	struct inode *inode = dentry->d_inode;
104 	size_t already_read = 0;
105 	off_t pos;
106 	size_t bufsize;
107 	int error;
108 	void* freepage;
109 	size_t freelen;
110 
111 	DPRINTK("ncp_file_read: enter %s/%s\n",
112 		dentry->d_parent->d_name.name, dentry->d_name.name);
113 
114 	pos = *ppos;
115 
116 	if ((ssize_t) count < 0) {
117 		return -EINVAL;
118 	}
119 	if (!count)
120 		return 0;
121 	if (pos > inode->i_sb->s_maxbytes)
122 		return 0;
123 	if (pos + count > inode->i_sb->s_maxbytes) {
124 		count = inode->i_sb->s_maxbytes - pos;
125 	}
126 
127 	error = ncp_make_open(inode, O_RDONLY);
128 	if (error) {
129 		DPRINTK(KERN_ERR "ncp_file_read: open failed, error=%d\n", error);
130 		return error;
131 	}
132 
133 	bufsize = NCP_SERVER(inode)->buffer_size;
134 
135 	error = -EIO;
136 	freelen = ncp_read_bounce_size(bufsize);
137 	freepage = vmalloc(freelen);
138 	if (!freepage)
139 		goto outrel;
140 	error = 0;
141 	/* First read in as much as possible for each bufsize. */
142 	while (already_read < count) {
143 		int read_this_time;
144 		size_t to_read = min_t(unsigned int,
145 				     bufsize - (pos % bufsize),
146 				     count - already_read);
147 
148 		error = ncp_read_bounce(NCP_SERVER(inode),
149 			 	NCP_FINFO(inode)->file_handle,
150 				pos, to_read, buf, &read_this_time,
151 				freepage, freelen);
152 		if (error) {
153 			error = -EIO;	/* NW errno -> Linux errno */
154 			break;
155 		}
156 		pos += read_this_time;
157 		buf += read_this_time;
158 		already_read += read_this_time;
159 
160 		if (read_this_time != to_read) {
161 			break;
162 		}
163 	}
164 	vfree(freepage);
165 
166 	*ppos = pos;
167 
168 	file_accessed(file);
169 
170 	DPRINTK("ncp_file_read: exit %s/%s\n",
171 		dentry->d_parent->d_name.name, dentry->d_name.name);
172 outrel:
173 	ncp_inode_close(inode);
174 	return already_read ? already_read : error;
175 }
176 
177 static ssize_t
ncp_file_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)178 ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
179 {
180 	struct dentry *dentry = file->f_path.dentry;
181 	struct inode *inode = dentry->d_inode;
182 	size_t already_written = 0;
183 	off_t pos;
184 	size_t bufsize;
185 	int errno;
186 	void* bouncebuffer;
187 
188 	DPRINTK("ncp_file_write: enter %s/%s\n",
189 		dentry->d_parent->d_name.name, dentry->d_name.name);
190 	if ((ssize_t) count < 0)
191 		return -EINVAL;
192 	pos = *ppos;
193 	if (file->f_flags & O_APPEND) {
194 		pos = i_size_read(inode);
195 	}
196 
197 	if (pos + count > MAX_NON_LFS && !(file->f_flags&O_LARGEFILE)) {
198 		if (pos >= MAX_NON_LFS) {
199 			return -EFBIG;
200 		}
201 		if (count > MAX_NON_LFS - (u32)pos) {
202 			count = MAX_NON_LFS - (u32)pos;
203 		}
204 	}
205 	if (pos >= inode->i_sb->s_maxbytes) {
206 		if (count || pos > inode->i_sb->s_maxbytes) {
207 			return -EFBIG;
208 		}
209 	}
210 	if (pos + count > inode->i_sb->s_maxbytes) {
211 		count = inode->i_sb->s_maxbytes - pos;
212 	}
213 
214 	if (!count)
215 		return 0;
216 	errno = ncp_make_open(inode, O_WRONLY);
217 	if (errno) {
218 		DPRINTK(KERN_ERR "ncp_file_write: open failed, error=%d\n", errno);
219 		return errno;
220 	}
221 	bufsize = NCP_SERVER(inode)->buffer_size;
222 
223 	already_written = 0;
224 
225 	bouncebuffer = vmalloc(bufsize);
226 	if (!bouncebuffer) {
227 		errno = -EIO;	/* -ENOMEM */
228 		goto outrel;
229 	}
230 	while (already_written < count) {
231 		int written_this_time;
232 		size_t to_write = min_t(unsigned int,
233 				      bufsize - (pos % bufsize),
234 				      count - already_written);
235 
236 		if (copy_from_user(bouncebuffer, buf, to_write)) {
237 			errno = -EFAULT;
238 			break;
239 		}
240 		if (ncp_write_kernel(NCP_SERVER(inode),
241 		    NCP_FINFO(inode)->file_handle,
242 		    pos, to_write, bouncebuffer, &written_this_time) != 0) {
243 			errno = -EIO;
244 			break;
245 		}
246 		pos += written_this_time;
247 		buf += written_this_time;
248 		already_written += written_this_time;
249 
250 		if (written_this_time != to_write) {
251 			break;
252 		}
253 	}
254 	vfree(bouncebuffer);
255 
256 	file_update_time(file);
257 
258 	*ppos = pos;
259 
260 	if (pos > i_size_read(inode)) {
261 		mutex_lock(&inode->i_mutex);
262 		if (pos > i_size_read(inode))
263 			i_size_write(inode, pos);
264 		mutex_unlock(&inode->i_mutex);
265 	}
266 	DPRINTK("ncp_file_write: exit %s/%s\n",
267 		dentry->d_parent->d_name.name, dentry->d_name.name);
268 outrel:
269 	ncp_inode_close(inode);
270 	return already_written ? already_written : errno;
271 }
272 
ncp_release(struct inode * inode,struct file * file)273 static int ncp_release(struct inode *inode, struct file *file) {
274 	if (ncp_make_closed(inode)) {
275 		DPRINTK("ncp_release: failed to close\n");
276 	}
277 	return 0;
278 }
279 
280 const struct file_operations ncp_file_operations =
281 {
282 	.llseek		= generic_file_llseek,
283 	.read		= ncp_file_read,
284 	.write		= ncp_file_write,
285 	.unlocked_ioctl	= ncp_ioctl,
286 #ifdef CONFIG_COMPAT
287 	.compat_ioctl	= ncp_compat_ioctl,
288 #endif
289 	.mmap		= ncp_mmap,
290 	.release	= ncp_release,
291 	.fsync		= ncp_fsync,
292 };
293 
294 const struct inode_operations ncp_file_inode_operations =
295 {
296 	.setattr	= ncp_notify_change,
297 };
298