This source file includes following definitions.
- ext2_file_read
- ext2_file_write
- ext2_release_file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 #include <asm/segment.h>
19 #include <asm/system.h>
20
21 #include <linux/errno.h>
22 #include <linux/fs.h>
23 #include <linux/ext2_fs.h>
24 #include <linux/fcntl.h>
25 #include <linux/sched.h>
26 #include <linux/stat.h>
27 #include <linux/locks.h>
28
29 #define NBUF 32
30
31 #define MIN(a,b) (((a)<(b))?(a):(b))
32 #define MAX(a,b) (((a)>(b))?(a):(b))
33
34 #include <linux/fs.h>
35 #include <linux/ext2_fs.h>
36
37 static int ext2_file_read (struct inode *, struct file *, char *, int);
38 static int ext2_file_write (struct inode *, struct file *, const char *, int);
39 static void ext2_release_file (struct inode *, struct file *);
40
41
42
43
44
45 static struct file_operations ext2_file_operations = {
46 NULL,
47 ext2_file_read,
48 ext2_file_write,
49 NULL,
50 NULL,
51 ext2_ioctl,
52 generic_mmap,
53 NULL,
54 ext2_release_file,
55 ext2_sync_file,
56 NULL,
57 NULL,
58 NULL
59 };
60
61 struct inode_operations ext2_file_inode_operations = {
62 &ext2_file_operations,
63 NULL,
64 NULL,
65 NULL,
66 NULL,
67 NULL,
68 NULL,
69 NULL,
70 NULL,
71 NULL,
72 NULL,
73 NULL,
74 ext2_bmap,
75 ext2_truncate,
76 ext2_permission,
77 NULL
78 };
79
80 static int ext2_file_read (struct inode * inode, struct file * filp,
81 char * buf, int count)
82 {
83 int read, left, chars;
84 int block, blocks, offset;
85 int bhrequest, uptodate;
86 int clusterblocks;
87 struct buffer_head ** bhb, ** bhe;
88 struct buffer_head * bhreq[NBUF];
89 struct buffer_head * buflist[NBUF];
90 struct super_block * sb;
91 unsigned int size;
92 int err;
93
94 if (!inode) {
95 printk ("ext2_file_read: inode = NULL\n");
96 return -EINVAL;
97 }
98 sb = inode->i_sb;
99 if (!S_ISREG(inode->i_mode)) {
100 ext2_warning (sb, "ext2_file_read", "mode = %07o",
101 inode->i_mode);
102 return -EINVAL;
103 }
104 offset = filp->f_pos;
105 size = inode->i_size;
106 if (offset > size)
107 left = 0;
108 else
109 left = size - offset;
110 if (left > count)
111 left = count;
112 if (left <= 0)
113 return 0;
114 read = 0;
115 block = offset >> EXT2_BLOCK_SIZE_BITS(sb);
116 offset &= (sb->s_blocksize - 1);
117 chars = sb->s_blocksize - offset;
118 size = (size + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
119 blocks = (left + offset + sb->s_blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(sb);
120 bhb = bhe = buflist;
121 if (filp->f_reada) {
122 if (blocks < read_ahead[MAJOR(inode->i_dev)] >> (EXT2_BLOCK_SIZE_BITS(sb) - 9))
123 blocks = read_ahead[MAJOR(inode->i_dev)] >> (EXT2_BLOCK_SIZE_BITS(sb) - 9);
124 if (block + blocks > size)
125 blocks = size - block;
126 }
127
128
129
130
131
132
133
134
135
136
137
138
139
140 clusterblocks = 0;
141
142 do {
143 bhrequest = 0;
144 uptodate = 1;
145 while (blocks) {
146 --blocks;
147 #if 1
148 if(!clusterblocks) clusterblocks = ext2_getcluster(inode, block);
149 if(clusterblocks) clusterblocks--;
150 #endif
151
152 *bhb = ext2_getblk (inode, block++, 0, &err);
153 if (*bhb && !buffer_uptodate(*bhb)) {
154 uptodate = 0;
155 bhreq[bhrequest++] = *bhb;
156 }
157
158 if (++bhb == &buflist[NBUF])
159 bhb = buflist;
160
161
162
163
164
165 if (uptodate)
166 break;
167
168 if (bhb == bhe)
169 break;
170 }
171
172
173
174
175 if (bhrequest)
176 ll_rw_block (READ, bhrequest, bhreq);
177
178 do {
179
180
181
182 if (*bhe) {
183 wait_on_buffer (*bhe);
184 if (!buffer_uptodate(*bhe)) {
185 brelse(*bhe);
186 if (++bhe == &buflist[NBUF])
187 bhe = buflist;
188 left = 0;
189 break;
190 }
191 }
192 left -= chars;
193 if (left < 0)
194 chars += left;
195 filp->f_pos += chars;
196 read += chars;
197 if (*bhe) {
198 memcpy_tofs (buf, offset + (*bhe)->b_data,
199 chars);
200 brelse (*bhe);
201 buf += chars;
202 } else {
203 while (chars-- > 0)
204 put_user (0, buf++);
205 }
206 offset = 0;
207 chars = sb->s_blocksize;
208 if (++bhe == &buflist[NBUF])
209 bhe = buflist;
210 } while (left > 0 && bhe != bhb && (!*bhe || !buffer_locked(*bhe)));
211 } while (left > 0);
212
213
214
215
216 while (bhe != bhb) {
217 brelse (*bhe);
218 if (++bhe == &buflist[NBUF])
219 bhe = buflist;
220 }
221 if (!read)
222 return -EIO;
223 filp->f_reada = 1;
224 if (!IS_RDONLY(inode)) {
225 inode->i_atime = CURRENT_TIME;
226 inode->i_dirt = 1;
227 }
228 return read;
229 }
230
231 static int ext2_file_write (struct inode * inode, struct file * filp,
232 const char * buf, int count)
233 {
234 const loff_t two_gb = 2147483647;
235 loff_t pos;
236 off_t pos2;
237 long block;
238 int offset;
239 int written, c;
240 struct buffer_head * bh, *bufferlist[NBUF];
241 struct super_block * sb;
242 int err;
243 int i,buffercount,write_error;
244
245 write_error = buffercount = 0;
246 if (!inode) {
247 printk("ext2_file_write: inode = NULL\n");
248 return -EINVAL;
249 }
250 sb = inode->i_sb;
251 if (sb->s_flags & MS_RDONLY)
252
253
254
255 return -ENOSPC;
256
257 if (!S_ISREG(inode->i_mode)) {
258 ext2_warning (sb, "ext2_file_write", "mode = %07o",
259 inode->i_mode);
260 return -EINVAL;
261 }
262 if (filp->f_flags & O_APPEND)
263 pos = inode->i_size;
264 else
265 pos = filp->f_pos;
266 pos2 = (off_t) pos;
267
268
269
270
271
272
273 if (filp->f_flags & O_SYNC)
274 inode->u.ext2_i.i_osync++;
275 block = pos2 >> EXT2_BLOCK_SIZE_BITS(sb);
276 offset = pos2 & (sb->s_blocksize - 1);
277 c = sb->s_blocksize - offset;
278 written = 0;
279 while (count > 0) {
280 if (pos > two_gb) {
281 if (!written)
282 written = -EFBIG;
283 break;
284 }
285 bh = ext2_getblk (inode, block, 1, &err);
286 if (!bh) {
287 if (!written)
288 written = err;
289 break;
290 }
291 count -= c;
292 if (count < 0)
293 c += count;
294 if (c != sb->s_blocksize && !buffer_uptodate(bh)) {
295 ll_rw_block (READ, 1, &bh);
296 wait_on_buffer (bh);
297 if (!buffer_uptodate(bh)) {
298 brelse (bh);
299 if (!written)
300 written = -EIO;
301 break;
302 }
303 }
304 pos2 += c;
305 pos += c;
306 written += c;
307 memcpy_fromfs (bh->b_data + offset, buf, c);
308 buf += c;
309 mark_buffer_uptodate(bh, 1);
310 mark_buffer_dirty(bh, 0);
311 if (filp->f_flags & O_SYNC)
312 bufferlist[buffercount++] = bh;
313 else
314 brelse(bh);
315 if (buffercount == NBUF){
316 ll_rw_block(WRITE, buffercount, bufferlist);
317 for(i=0; i<buffercount; i++){
318 wait_on_buffer(bufferlist[i]);
319 if (!buffer_uptodate(bufferlist[i]))
320 write_error=1;
321 brelse(bufferlist[i]);
322 }
323 buffercount=0;
324 }
325 if(write_error)
326 break;
327 block++;
328 offset = 0;
329 c = sb->s_blocksize;
330 }
331 if ( buffercount ){
332 ll_rw_block(WRITE, buffercount, bufferlist);
333 for(i=0; i<buffercount; i++){
334 wait_on_buffer(bufferlist[i]);
335 if (!buffer_uptodate(bufferlist[i]))
336 write_error=1;
337 brelse(bufferlist[i]);
338 }
339 }
340 if (pos > inode->i_size)
341 inode->i_size = pos;
342 if (filp->f_flags & O_SYNC)
343 inode->u.ext2_i.i_osync--;
344 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
345 filp->f_pos = pos;
346 inode->i_dirt = 1;
347 return written;
348 }
349
350
351
352
353
354
355 static void ext2_release_file (struct inode * inode, struct file * filp)
356 {
357 if (filp->f_mode & 2)
358 ext2_discard_prealloc (inode);
359 }