![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dblspace_fileops.c-2.3.99 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GPL Stacker compression] / dmsdos / src|
Return to dblspace_fileops.c-2.3.99 CVS log | Up to [GPL Stacker compression] / dmsdos / src |
1.1 root 1: /*
2: dblspace_fileops.c-2.1.80
3:
4: DMSDOS CVF-FAT module: file operation routines (for kernel>=2.1.80).
5:
6: ******************************************************************************
7: DMSDOS (compressed MSDOS filesystem support) for Linux
8: written 1995-1998 by Frank Gockel and Pavel Pisa
9:
10: (C) Copyright 1995-1998 by Frank Gockel
11: (C) Copyright 1996-1998 by Pavel Pisa
12:
13: Some code of dmsdos has been copied from the msdos filesystem
14: so there are the following additional copyrights:
15:
16: (C) Copyright 1992,1993 by Werner Almesberger (msdos filesystem)
17: (C) Copyright 1994,1995 by Jacques Gelinas (mmap code)
18: (C) Copyright 1992-1995 by Linus Torvalds
19:
20: DMSDOS was inspired by the THS filesystem (a simple doublespace
21: DS-0-2 compressed read-only filesystem) written 1994 by Thomas Scheuermann.
22:
23: The DMSDOS code is distributed under the Gnu General Public Licence.
24: See file COPYING for details.
25: ******************************************************************************
26:
27: */
28:
29: #include <linux/sched.h>
30: #include <linux/ctype.h>
31: #include <linux/major.h>
32: #include <linux/blkdev.h>
33: #include <linux/fs.h>
34: #include <linux/stat.h>
35: #include <linux/locks.h>
36: #include <asm/segment.h>
37: #include <linux/mm.h>
38: #include <linux/malloc.h>
39: #include <linux/string.h>
40: #include <linux/msdos_fs.h>
41: #include <linux/errno.h>
42: #include <linux/kernel.h>
43: #include <linux/shm.h>
44: #include <linux/mman.h>
45: #include <asm/system.h>
46: #include "dmsdos.h"
47:
48: extern unsigned long dmsdos_speedup;
49:
50: #define MIN(x,y) ( ( (x)<(y) ) ? (x) : (y) )
51:
52: void do_cluster_reada(struct super_block*sb,int clusternr)
53: { /* read one cluster ahead without waiting for the data */
54: int nextclust;
55:
56: nextclust=dbl_fat_nextcluster(sb,clusternr,NULL);
57: if(nextclust>0)
58: { /* no need to read-ahead if it is in cache */
59: /* for a simple search for existence we needn't lock the cache */
60: if(find_in_ccache(sb,nextclust,NULL,NULL)==NULL)
61: dmsdos_read_cluster(sb,NULL,nextclust);
62: }
63: }
64:
65: int dblspace_file_read(
66: struct file *filp,
67: char *buf,
68: size_t count,
69: loff_t *ppos)
70: {
71: int clusternr;
72: /*unsigned char*clusterd;*/
73: int offset;
74: int bytes_read;
75: int membytes;
76: int membytes_bits;
77: int ret;
78: char * b;
79: int toread;
80: Cluster_head*ch;
81: struct inode *inode;
82: struct super_block*sb;
83: Dblsb*dblsb;
84:
85: LOG_FS("DMSDOS: file_read start...\n");
86:
87: inode = filp->f_dentry->d_inode;
88: LOG_FS("DMSDOS: file_read: got inode\n");
89: sb=inode->i_sb;
90: LOG_FS("DMSDOS: file_read: got sb\n");
91: dblsb=MSDOS_SB(sb)->private_data;
92: LOG_FS("DMSDOS: file_read: got dblsb\n");
93:
94: if (!inode) {
95: printk(KERN_ERR "DMSDOS: file_read: inode = NULL, rejected.\n");
96: return -EINVAL;
97: }
98: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
99: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
100: printk(KERN_ERR "DMSDOS: file_read: mode = %07o, rejected.\n",inode->i_mode);
101: return -EINVAL;
102: }
103:
104: LOG_FS("DMSDOS: file_read init complete...\n");
105:
106: if(count<=0)return 0;
107:
108: if(*ppos>=inode->i_size)return 0;
109:
110: if(*ppos+count>inode->i_size)count=inode->i_size-*ppos;
111:
112: ret=verify_area(VERIFY_WRITE, buf, count);
113: if(ret<0)return ret;
114: ret=0;
115:
116: membytes=SECTOR_SIZE*dblsb->s_sectperclust;
117: membytes_bits=SECTOR_BITS+dblsb->s_spc_bits;
118:
119: /* calculate clusternr for cluster to read */
120: offset=*ppos&(membytes-1);
121: LOG_CLUST("DMSDOS: file_read: get_cluster...\n");
122: clusternr=get_cluster(inode,*ppos>>membytes_bits);
123: if(clusternr<=0)
124: { printk(KERN_ERR "DMSDOS: file_readx: FAT mismatches file size for ino=%ld\n",
125: inode->i_ino);
126: return 0;
127: }
128:
129: bytes_read=0;
130: b=buf;
131:
132: do
133: { LOG_CLUST("DMSDOS: file_read: calling ch_read...\n");
134: ch=ch_read(sb,clusternr,0);
135: LOG_CLUST("DMSDOS: file_read: after ch_read\n");
136: ret=(ch==NULL)?-EIO:0;
137: if(ret>=0)
138: { if(count>READA_THRESHOLD&&(dmsdos_speedup&SP_USE_READ_AHEAD)!=0)
139: do_cluster_reada(inode->i_sb,clusternr);
140: toread=(membytes-offset>count) ? count : membytes-offset;
141: /*printk("DMSDOS file_readx: memcpy_tofs(0x%08x,0x%08x,0x%08x)\n",
142: b,clusterd+offset,toread);*/
143: memcpy_tofs(b,ch->c_data+offset,toread);
144: bytes_read+=toread;
145: *ppos+=toread;
146: count-=toread;
147: ch_free(ch);
148: if(count>0)
149: { b+=toread;
150: offset=0;
151: LOG_CLUST("DMSDOS: file_read: get_cluster...\n");
152: clusternr=get_cluster(inode,*ppos>>membytes_bits);
153: if(*ppos&(membytes-1))
154: panic("DMSDOS: read_file bug: f_pos not cluster-aligned");
155: if(clusternr<=0)
156: { ret=-EIO;
157: printk(KERN_ERR "DMSDOS: file_readx: FAT mismatches file size for ino=%ld\n",
158: inode->i_ino);
159: }
160: }
161: }
162: }
163: while(count>0&&ret>=0);
164:
165: return (bytes_read==0&&ret<0)?ret:bytes_read;
166: }
167:
168: int dblspace_file_write(
169: struct file *filp,
170: const char *buf,
171: size_t count,
172: loff_t *ppos)
173: {
174: int cluster;
175: int ret=0;
176: unsigned int offset;
177: const unsigned char *b;
178: int canwrite;
179: int written;
180: int clustersize;
181: int clustersize_bits;
182: int uc;
183: Cluster_head*ch;
184: struct inode *inode = filp->f_dentry->d_inode;
185: struct super_block*sb=inode->i_sb;
186: Dblsb*dblsb=MSDOS_SB(sb)->private_data;
187:
188: if (!inode) {
189: printk(KERN_ERR "dmsdos_file_write: inode = NULL\n");
190: return -EINVAL;
191: }
192: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
193: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
194: printk(KERN_ERR "dmsdos_file_write: mode = %07o\n",inode->i_mode);
195: return -EINVAL;
196: }
197: /*
198: * ok, append may not work when many processes are writing at the same time
199: * but so what. That way leads to madness anyway.
200: */
201: if(sb->s_flags&MS_RDONLY)
202: { printk(KERN_ERR "DMSDOS: file_write: READ-ONLY filesystem\n");
203: return -EROFS;
204: }
205:
206: if(dblsb->s_comp==READ_ONLY)return -EPERM;
207:
208: if (filp->f_flags & O_APPEND) *ppos = inode->i_size;
209: if (count <= 0) return 0;
210:
211: ret=verify_area(VERIFY_READ, buf, count);
212: if(ret<0)return ret;
213: ret=0;
214:
215: clustersize=dblsb->s_sectperclust*SECTOR_SIZE;
216: clustersize_bits=dblsb->s_spc_bits+SECTOR_BITS;
217:
218: uc=0;
219: /* no longer working in 2.3.99...
220: if(dmsdos_speedup&SP_NO_EMD_COMPR)
221: uc=(MSDOS_I(inode)->i_binary>1)?1:0; / uncompressed forced /
222: */
223:
224: offset=*ppos&(clustersize-1);
225: do
226: { cluster=get_cluster(inode,*ppos>>clustersize_bits);
227: if(cluster>0)break;
228: if(dblsb->s_full==2)
229: { printk(KERN_ERR "DMSDOS: write_file: CVF full (full flag set)\n");
230: return -ENOSPC;
231: }
232: if(dblsb->s_free_sectors<MIN_FREE_SECTORS)
233: { printk(KERN_ERR "DMSDOS: write_file: CVF full (free sector count too low)\n");
234: return -ENOSPC;
235: }
236: if(fat_add_cluster(inode)<0)
237: { printk(KERN_ERR "DMSDOS: write_file: fat_add_cluster failed\n");
238: return -ENOSPC;
239: }
240: }
241: while(cluster<=0);
242:
243: LOG_CLUST("DMSDOS: file_write: beginning with cluster %d\n",
244: cluster);
245:
246: b=buf;
247: written=0;
248:
249: while(count>0)
250: {
251: if(offset>0||count<clustersize)
252: { /* cluster must be read because it will only partially overwritten */
253: LOG_CLUST("DMSDOS: write_file: reading cluster %d...\n",cluster);
254: ch=ch_read(sb,cluster,C_KEEP_LOCK);
255: if(ch==NULL)
256: { printk(KERN_ERR "DMSDOS: write_file: read_cluster failed!\n");
257: ret=-EIO;
258: break;
259: }
260: /*lock_ch(ch); we call with KEEP_LOCK above */
261: }
262: else
263: { /* cluster will be fully overwritten, don't read it */
264: ch=ch_read(sb,cluster,C_KEEP_LOCK|C_NO_READ);
265: if(ch==NULL)
266: { printk(KERN_ERR "DMSDOS: write_file: ch_noread failed!\n");
267: ret=-EIO;
268: break;
269: }
270: /*lock_ch(ch); we call with KEEP_LOCK above */
271: ch->c_length= (count+offset<clustersize) ?
272: count+offset : clustersize;
273: }
274: canwrite=MIN(clustersize-offset,count);
275: memcpy_fromfs(&(ch->c_data[offset]),b,canwrite);
276:
277: /* did cluster grow ? */
278: if(canwrite+offset>ch->c_length)
279: { /*printk(KERN_ERR "DMSDOS: write_file: write beyond logical cluster end, appending.\n");
280: */
281: ch->c_length=canwrite+offset;
282: }
283: if(ch->c_length>clustersize)
284: { printk(KERN_ERR "DMSDOS: write_file: length>clustersize ??? bug !!!\n");
285: ch->c_length=clustersize;
286: }
287:
288: /*unlock_ch(ch); no not here*/
289:
290: LOG_CLUST("DMSDOS: write_file: writing cluster %d...\n",cluster);
291:
292: /* ch_dirty_locked unlocks the cluster */
293: if(ch_dirty_locked(ch,0,uc)<0)
294: { printk(KERN_ERR "DMSDOS: write_file: ch_dirty failed!\n");
295: ch_free(ch);
296: ch=NULL;
297: ret=-EIO;
298: break;
299: }
300: ch_free(ch);
301: ch=NULL;
302:
303: offset=0;
304: b+=canwrite;
305: *ppos+=canwrite;
306: written+=canwrite;
307: count-=canwrite;
308:
309: if(count==0)break; /* braucht keinen neuen cluster mehr*/
310:
311: /* next cluster ? */
312: cluster=get_cluster(inode,*ppos>>clustersize_bits);
313: if(cluster<=0)
314: { LOG_CLUST("DMSDOS: write_file: write_loop: allocating new cluster\n");
315: if(dblsb->s_full==2)
316: { printk(KERN_ERR "DMSDOS: write_file: CVF full (full flag set)\n");
317: ret=-ENOSPC;
318: break;
319: }
320: if(dblsb->s_free_sectors<MIN_FREE_SECTORS)
321: { printk(KERN_ERR "DMSDOS: write_file: CVF full (free sector count too low)\n");
322: ret=-ENOSPC;
323: break;
324: }
325: if(fat_add_cluster(inode)<0)
326: { printk(KERN_ERR "DMSDOS: write_file: fat_add_cluster failed\n");
327: ret=-ENOSPC;
328: break;
329: }
330: cluster=get_cluster(inode,*ppos>>clustersize_bits);
331: if(cluster<=0)
332: { printk(KERN_ERR "DMSDOS: write_file: something's wrong, cannot happen\n");
333: ret=-EIO;
334: break;
335: }
336: }
337: }
338:
339: if(*ppos>inode->i_size)
340: { inode->i_size=*ppos;
341: /*inode->i_dirt=1; .... HMMM .... */
342: mark_inode_dirty(inode);
343: }
344:
345: return (written==0)?ret:written;
346: }
347:
348:
349: /* Grmpf.... partially untested code. Don't know an application that does
350: writable mmaps, but it would be needed for testing this piece of code */
351:
352: /* idea: kernel does buffer reads with bmap calculated buffers - impossible
353: for dmsdos. (see kernel mmap code).
354: kernel emulates writable mmap by calling file_write when no buffers
355: are present - should work for dmsdos.
356: so we do file_read-emulated readable mmaps here though the
357: generic_mmap function is used.
358: */
359:
360: #ifdef DMSDOS_USE_READPAGE
361:
362: #ifdef __FOR_KERNEL_2_3_99
363: #error kernels >= 2.3.99 need mmap interface
364: #endif
365:
366: int read_the_page(unsigned long address, unsigned long pos,
367: struct inode*inode)
368: {
369: unsigned int clear;
370: long gap; /* distance from eof to pos */
371:
372: LOG_FS("DMSDOS: read_the_page\n");
373:
374: address &= PAGE_MASK;
375:
376: clear = 0;
377: gap = inode->i_size - pos;
378: if (gap <= 0){
379: /* mmaping beyond end of file */
380: clear = PAGE_SIZE;
381: }else{
382: int cur_read;
383: int need_read;
384: struct file filp;
385: if (gap < PAGE_SIZE){
386: clear = PAGE_SIZE - gap;
387: }
388: filp.f_reada = 0;
389: filp.f_pos = pos;
390: need_read = PAGE_SIZE - clear;
391: { mm_segment_t cur_fs = get_fs();
392: filp.f_dentry=kmalloc(sizeof(struct dentry),GFP_KERNEL);
393: if(filp.f_dentry==NULL)
394: { printk(KERN_ERR "DMSDOS: read_the_page: no memory!\n");
395: return -1;
396: }
397: filp.f_dentry->d_inode=inode;
398:
399: set_fs (KERNEL_DS);
400: LOG_FS("DMSDOS: read_the_page: calling file_read...\n");
401: cur_read = dblspace_file_read (&filp,
402: (char*)address,
403: need_read,
404: &(filp.f_pos));
405: set_fs (cur_fs);
406: kfree(filp.f_dentry);
407: }
408: if (cur_read != need_read){
409: printk ("DMSDOS: Error while reading an mmap file %d <> %d\n"
410: ,cur_read,need_read);
411: return -1;
412: }
413: }
414: if (clear > 0){
415: memset ((char*)address+PAGE_SIZE-clear,0,clear);
416: }
417: return 0;
418: }
419:
420: #ifdef READPAGE_DENTRY
421: int dblspace_readpage(struct dentry*dentry, struct page *page)
422: { unsigned long address;
423: int error = -1;
424: struct inode*inode=dentry->d_inode;
425: #else
426: int dblspace_readpage(struct inode *inode, struct page *page)
427: { unsigned long address;
428: int error = -1;
429: #endif
430: LOG_FS("DMSDOS: readpage %08lx\n", page_address(page));
431:
432: address = page_address(page);
433: atomic_inc(&page->count);
434: set_bit(PG_locked, &page->flags);
435:
436: /* now read the data */
437: error=read_the_page(address,page->offset,inode);
438:
439: LOG_FS("DMSDOS: readpage: read_the_page returned %d\n",error);
440:
441: if(error==0)set_bit(PG_uptodate, &page->flags);
442:
443: clear_bit(PG_locked, &page->flags);
444: wake_up(&page->wait);
445:
446: free_page(address);
447: return error;
448: }
449:
450: #else /* from: ifdef DMSDOS_USE_READPAGE */
451:
452: /* this is supposed to be obsolete stuff for older kernels... */
453:
454: /* we reactivate it for 2.3.99 kernel */
455:
456: /*
457: * Fill in the supplied page for mmap
458: */
459: struct page* dblspace_file_mmap_nopage(
460: struct vm_area_struct * area,
461: unsigned long address,
462: int write_access)
463: {
464: struct inode * inode = area->vm_file->f_dentry->d_inode;
465: struct page* page;
466: unsigned int clear;
467: int pos;
468: long gap; /* distance from eof to pos */
469:
470: LOG_FS("DMSDOS: file_mmap_nopage\n");
471: /*page = __get_free_page(GFP_KERNEL);*/
472: page=alloc_pages(GFP_KERNEL,0);
473: if (!page)return NULL;
474: LOG_FS("DMSDOS: file_mmap_nopage: got page\n");
475:
476: address &= PAGE_MASK;
477: pos = address - area->vm_start + area->vm_pgoff*PAGE_SIZE;
478:
479: clear = 0;
480: gap = inode->i_size - pos;
481: if (gap <= 0){
482: /* mmaping beyond end of file */
483: clear = PAGE_SIZE;
484: }else{
485: int cur_read;
486: int need_read;
487: struct file filp;
488: if (gap < PAGE_SIZE){
489: clear = PAGE_SIZE - gap;
490: }
491: filp.f_reada = 0;
492: filp.f_pos = pos;
493: need_read = PAGE_SIZE - clear;
494: { mm_segment_t cur_fs = get_fs();
495: filp.f_dentry=kmalloc(sizeof(struct dentry),GFP_KERNEL);
496: if(filp.f_dentry==NULL)
497: { printk(KERN_ERR "DMSDOS: file_mmap_nopage: no memory!\n");
498: return NULL;
499: }
500: filp.f_dentry->d_inode=inode;
501:
502: set_fs (KERNEL_DS);
503: LOG_FS("DMSDOS: file_mmap_nopage: calling file_read...\n");
504: cur_read = dblspace_file_read(&filp,
505: (char*)page_address(page),
506: need_read,&filp.f_pos);
507: LOG_FS("DMSDOS: file_mmap_nopage: file_read returned\n");
508: set_fs (cur_fs);
509: kfree(filp.f_dentry);
510: }
511: if (cur_read != need_read){
512: printk ("DMSDOS: Error while reading an mmap file %d <> %d\n"
513: ,cur_read,need_read);
514: }
515: }
516: if (clear > 0){
517: memset ((char*)page+PAGE_SIZE-clear,0,clear);
518: }
519: LOG_FS("DMSDOS: file_mmap_nopage: end\n");
520: return page;
521: }
522:
523: struct vm_operations_struct dblspace_file_mmap = {
524: NULL, /* open */
525: NULL, /* close */
526: NULL, /* unmap */
527: NULL, /* protect */
528: NULL, /* sync */
529: dblspace_file_mmap_nopage, /* nopage */
530: NULL, /* wppage */
531: NULL, /* swapout */
532: };
533:
534: /*
535: * This is used for a general mmap of a dmsdos file
536: * Returns 0 if ok, or a negative error code if not.
537: */
538: int dblspace_mmap(struct file*file,struct vm_area_struct*vma)
539: { struct inode *inode = file->f_dentry->d_inode;
540: LOG_FS("DMSDOS: mmap ino=%ld\n",inode->i_ino);
541: if (vma->vm_flags & VM_SHARED) /* only PAGE_COW or read-only supported now */
542: return -EINVAL;
543: /*
544: if (vma->vm_offset & (inode->i_sb->s_blocksize - 1))
545: return -EINVAL;
546: */
547: if (!inode->i_sb || !S_ISREG(inode->i_mode))
548: return -EACCES;
549: if (!IS_RDONLY(inode)) {
550: inode->i_atime = CURRENT_TIME;
551: /*inode->i_dirt = 1;*/
552: mark_inode_dirty(inode);
553: }
554:
555: vma->vm_file = file;
556: vma->vm_ops = &dblspace_file_mmap;
557: return 0;
558: }
559:
560: #endif /* from: else / ifdef DMSDOS_USE_READPAGE */
561:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.