![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dblspace_fileops.c-2.1.80 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.1.80 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: char datum;
81: int need_cluster;
82: Cluster_head*ch;
83: struct inode *inode;
84: struct super_block*sb;
85: Dblsb*dblsb;
86:
87: LOG_FS("DMSDOS: file_read start...\n");
88:
89: inode = filp->f_dentry->d_inode;
90: LOG_FS("DMSDOS: file_read: got inode\n");
91: sb=inode->i_sb;
92: LOG_FS("DMSDOS: file_read: got sb\n");
93: dblsb=MSDOS_SB(sb)->private_data;
94: LOG_FS("DMSDOS: file_read: got dblsb\n");
95:
96: if (!inode) {
97: printk(KERN_ERR "DMSDOS: file_read: inode = NULL, rejected.\n");
98: return -EINVAL;
99: }
100: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
101: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
102: printk(KERN_ERR "DMSDOS: file_read: mode = %07o, rejected.\n",inode->i_mode);
103: return -EINVAL;
104: }
105:
106: LOG_FS("DMSDOS: file_read init complete...\n");
107:
108: if(count<=0)return 0;
109:
110: if(*ppos>=inode->i_size)return 0;
111:
112: if(*ppos+count>inode->i_size)count=inode->i_size-*ppos;
113:
114: ret=verify_area(VERIFY_WRITE, buf, count);
115: if(ret<0)return ret;
116: ret=0;
117:
118: membytes=SECTOR_SIZE*dblsb->s_sectperclust;
119: membytes_bits=SECTOR_BITS+dblsb->s_spc_bits;
120:
121: /* calculate clusternr for cluster to read */
122: offset=*ppos&(membytes-1);
123: LOG_CLUST("DMSDOS: file_read: get_cluster...\n");
124: clusternr=get_cluster(inode,*ppos>>membytes_bits);
125: if(clusternr<=0)
126: { printk(KERN_ERR "DMSDOS: file_readx: FAT mismatches file size for ino=%ld\n",
127: inode->i_ino);
128: return 0;
129: }
130:
131: bytes_read=0;
132: b=buf;
133:
134: if(MSDOS_I(inode)->i_binary==0)goto text_read;
135:
136: do
137: { LOG_CLUST("DMSDOS: file_read: calling ch_read...\n");
138: ch=ch_read(sb,clusternr,0);
139: LOG_CLUST("DMSDOS: file_read: after ch_read\n");
140: ret=(ch==NULL)?-EIO:0;
141: if(ret>=0)
142: { if(count>READA_THRESHOLD&&(dmsdos_speedup&SP_USE_READ_AHEAD)!=0)
143: do_cluster_reada(inode->i_sb,clusternr);
144: toread=(membytes-offset>count) ? count : membytes-offset;
145: /*printk("DMSDOS file_readx: memcpy_tofs(0x%08x,0x%08x,0x%08x)\n",
146: b,clusterd+offset,toread);*/
147: memcpy_tofs(b,ch->c_data+offset,toread);
148: bytes_read+=toread;
149: *ppos+=toread;
150: count-=toread;
151: ch_free(ch);
152: if(count>0)
153: { b+=toread;
154: offset=0;
155: LOG_CLUST("DMSDOS: file_read: get_cluster...\n");
156: clusternr=get_cluster(inode,*ppos>>membytes_bits);
157: if(*ppos&(membytes-1))
158: panic("DMSDOS: read_file bug: f_pos not cluster-aligned");
159: if(clusternr<=0)
160: { ret=-EIO;
161: printk(KERN_ERR "DMSDOS: file_readx: FAT mismatches file size for ino=%ld\n",
162: inode->i_ino);
163: }
164: }
165: }
166: }
167: while(count>0&&ret>=0);
168:
169: return (bytes_read==0&&ret<0)?ret:bytes_read;
170:
171: text_read:
172: /* ok, let's do it byte for byte..... */
173: bytes_read=0;
174: need_cluster=1;
175: ch=NULL;
176: while(count>0&&inode->i_size>*ppos)
177: { if(need_cluster)
178: { clusternr=get_cluster(inode,*ppos>>membytes_bits);
179: if(clusternr<=0)
180: { printk(KERN_ERR "DMSDOS: get_cluster failed (FAT problem ?)\n");
181: return -EIO;
182: }
183: ch=ch_read(sb,clusternr,0);
184: if(ch==NULL)return -EIO;
185: if(count>READA_THRESHOLD&&(dmsdos_speedup&SP_USE_READ_AHEAD)!=0)
186: do_cluster_reada(inode->i_sb,clusternr);
187: clusternr=dbl_fat_nextcluster(sb,clusternr,NULL);
188: need_cluster=0;
189: }
190:
191: datum=ch->c_data[offset++];
192:
193: ++(*ppos);
194: if(datum!=13)
195: { /*put_fs_byte(datum,&(buf[bytes_read]));*/
196: memcpy_tofs(&(buf[bytes_read]),&datum,1);
197: ++bytes_read;
198: --count;
199: }
200: if(offset==membytes)
201: { need_cluster=1;
202: ch_free(ch);
203: ch=NULL;
204: offset=0;
205: }
206: }
207:
208: if(ch)ch_free(ch);
209: return bytes_read;
210: }
211:
212: int dblspace_file_write(
213: struct file *filp,
214: const char *buf,
215: size_t count,
216: loff_t *ppos)
217: {
218: int cluster;
219: int ret=0;
220: unsigned int offset;
221: const unsigned char *b;
222: int canwrite;
223: int written;
224: int clustersize;
225: int clustersize_bits;
226: int uc;
227: int cr;
228: char datum;
229: int need_cluster;
230: Cluster_head*ch;
231: struct inode *inode = filp->f_dentry->d_inode;
232: struct super_block*sb=inode->i_sb;
233: Dblsb*dblsb=MSDOS_SB(sb)->private_data;
234:
235: if (!inode) {
236: printk(KERN_ERR "dmsdos_file_write: inode = NULL\n");
237: return -EINVAL;
238: }
239: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
240: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
241: printk(KERN_ERR "dmsdos_file_write: mode = %07o\n",inode->i_mode);
242: return -EINVAL;
243: }
244: /*
245: * ok, append may not work when many processes are writing at the same time
246: * but so what. That way leads to madness anyway.
247: */
248: if(sb->s_flags&MS_RDONLY)
249: { printk(KERN_ERR "DMSDOS: file_write: READ-ONLY filesystem\n");
250: return -EROFS;
251: }
252:
253: if(dblsb->s_comp==READ_ONLY)return -EPERM;
254:
255: if (filp->f_flags & O_APPEND) *ppos = inode->i_size;
256: if (count <= 0) return 0;
257:
258: ret=verify_area(VERIFY_READ, buf, count);
259: if(ret<0)return ret;
260: ret=0;
261:
262: clustersize=dblsb->s_sectperclust*SECTOR_SIZE;
263: clustersize_bits=dblsb->s_spc_bits+SECTOR_BITS;
264:
265: uc=0;
266: if(dmsdos_speedup&SP_NO_EMD_COMPR)
267: uc=(MSDOS_I(inode)->i_binary>1)?1:0; /* uncompressed forced */
268:
269: offset=*ppos&(clustersize-1);
270: do
271: { cluster=get_cluster(inode,*ppos>>clustersize_bits);
272: if(cluster>0)break;
273: if(dblsb->s_full==2)
274: { printk(KERN_ERR "DMSDOS: write_file: CVF full (full flag set)\n");
275: return -ENOSPC;
276: }
277: if(dblsb->s_free_sectors<MIN_FREE_SECTORS)
278: { printk(KERN_ERR "DMSDOS: write_file: CVF full (free sector count too low)\n");
279: return -ENOSPC;
280: }
281: if(fat_add_cluster(inode)<0)
282: { printk(KERN_ERR "DMSDOS: write_file: fat_add_cluster failed\n");
283: return -ENOSPC;
284: }
285: }
286: while(cluster<=0);
287:
288: LOG_CLUST("DMSDOS: file_write: beginning with cluster %d\n",
289: cluster);
290:
291: b=buf;
292: written=0;
293:
294: if(MSDOS_I(inode)->i_binary==0)goto text_write;
295:
296: while(count>0)
297: {
298: if(offset>0||count<clustersize)
299: { /* cluster must be read because it will only partially overwritten */
300: LOG_CLUST("DMSDOS: write_file: reading cluster %d...\n",cluster);
301: ch=ch_read(sb,cluster,C_KEEP_LOCK);
302: if(ch==NULL)
303: { printk(KERN_ERR "DMSDOS: write_file: read_cluster failed!\n");
304: ret=-EIO;
305: break;
306: }
307: /*lock_ch(ch); we call with KEEP_LOCK above */
308: }
309: else
310: { /* cluster will be fully overwritten, don't read it */
311: ch=ch_read(sb,cluster,C_KEEP_LOCK|C_NO_READ);
312: if(ch==NULL)
313: { printk(KERN_ERR "DMSDOS: write_file: ch_noread failed!\n");
314: ret=-EIO;
315: break;
316: }
317: /*lock_ch(ch); we call with KEEP_LOCK above */
318: ch->c_length= (count+offset<clustersize) ?
319: count+offset : clustersize;
320: }
321: canwrite=MIN(clustersize-offset,count);
322: memcpy_fromfs(&(ch->c_data[offset]),b,canwrite);
323:
324: /* did cluster grow ? */
325: if(canwrite+offset>ch->c_length)
326: { /*printk(KERN_ERR "DMSDOS: write_file: write beyond logical cluster end, appending.\n");
327: */
328: ch->c_length=canwrite+offset;
329: }
330: if(ch->c_length>clustersize)
331: { printk(KERN_ERR "DMSDOS: write_file: length>clustersize ??? bug !!!\n");
332: ch->c_length=clustersize;
333: }
334:
335: /*unlock_ch(ch); no not here*/
336:
337: LOG_CLUST("DMSDOS: write_file: writing cluster %d...\n",cluster);
338:
339: /* ch_dirty_locked unlocks the cluster */
340: if(ch_dirty_locked(ch,0,uc)<0)
341: { printk(KERN_ERR "DMSDOS: write_file: ch_dirty failed!\n");
342: ch_free(ch);
343: ch=NULL;
344: ret=-EIO;
345: break;
346: }
347: ch_free(ch);
348: ch=NULL;
349:
350: offset=0;
351: b+=canwrite;
352: *ppos+=canwrite;
353: written+=canwrite;
354: count-=canwrite;
355:
356: if(count==0)break; /* braucht keinen neuen cluster mehr*/
357:
358: /* next cluster ? */
359: cluster=get_cluster(inode,*ppos>>clustersize_bits);
360: if(cluster<=0)
361: { LOG_CLUST("DMSDOS: write_file: write_loop: allocating new cluster\n");
362: if(dblsb->s_full==2)
363: { printk(KERN_ERR "DMSDOS: write_file: CVF full (full flag set)\n");
364: ret=-ENOSPC;
365: break;
366: }
367: if(dblsb->s_free_sectors<MIN_FREE_SECTORS)
368: { printk(KERN_ERR "DMSDOS: write_file: CVF full (free sector count too low)\n");
369: ret=-ENOSPC;
370: break;
371: }
372: if(fat_add_cluster(inode)<0)
373: { printk(KERN_ERR "DMSDOS: write_file: fat_add_cluster failed\n");
374: ret=-ENOSPC;
375: break;
376: }
377: cluster=get_cluster(inode,*ppos>>clustersize_bits);
378: if(cluster<=0)
379: { printk(KERN_ERR "DMSDOS: write_file: something's wrong, cannot happen\n");
380: ret=-EIO;
381: break;
382: }
383: }
384: }
385:
386: if(*ppos>inode->i_size)
387: { inode->i_size=*ppos;
388: /*inode->i_dirt=1; .... HMMM .... */
389: mark_inode_dirty(inode);
390: }
391:
392: return (written==0)?ret:written;
393:
394: text_write:
395: written=0;
396: need_cluster=1;
397: cr=0;
398: ch=NULL;
399: while(count>0||cr==1)
400: { if(need_cluster)
401: { LOG_CLUST("DMSDOS: text_write: need_cluster=%d\n",
402: cluster);
403: /* we cannot simply calculate here...
404: so we never know and must always read the cluster */
405: ch=ch_read(sb,cluster,C_KEEP_LOCK);
406: if(ch==NULL)
407: { printk(KERN_ERR "DMSDOS: write_file: read_cluster failed!\n");
408: ret=-EIO;
409: break;
410: }
411: /*lock_ch(ch); we call with KEEP_LOCK above */
412: need_cluster=0;
413: }
414:
415: if(cr==1)
416: { datum=10;
417: cr=0;
418: }
419: else
420: { /*datum=get_fs_byte(&(buf[written]));*/
421: memcpy_fromfs(&datum,&(buf[written]),1);
422: ++written;
423: if(datum==10)
424: { datum=13;
425: cr=1;
426: }
427: --count;
428: }
429:
430: ch->c_data[offset++]=datum;
431:
432: ++(*ppos);
433: if(offset>ch->c_length)ch->c_length=offset;
434:
435: if(offset==clustersize)
436: { /* cluster is full and must be written back */
437: /*unlock_ch(ch);*/
438: /* ch_dirty_locked unlocks the cluster *after* write */
439: if(ch_dirty_locked(ch,0,uc)<0)
440: { printk(KERN_ERR "DMSDOS: write_file: ch_dirty failed!\n");
441: ch_free(ch);
442: ch=NULL;
443: ret=-EIO;
444: break;
445: }
446: ch_free(ch);
447: ch=NULL;
448:
449: /*check whether end reached */
450: if(count==0&&cr==0)
451: { offset=0; /* tells that there's no rest */
452: break;
453: }
454: /* check whether a new cluster is needed */
455: cluster=get_cluster(inode,*ppos>>clustersize_bits);
456: if(cluster<=0)
457: {
458: if(dblsb->s_full==2)
459: { printk(KERN_ERR "DMSDOS: write_file: CVF full (full flag set)\n");
460: ret=-ENOSPC;
461: break;
462: }
463: if(dblsb->s_free_sectors<MIN_FREE_SECTORS)
464: { printk(KERN_ERR "DMSDOS: write_file: CVF full (free sector count too low)\n");
465: ret=-ENOSPC;
466: break;
467: }
468: if(fat_add_cluster(inode)<0)
469: { printk(KERN_ERR "DMSDOS: write_file: fat_add_cluster failed\n");
470: ret=-ENOSPC;
471: break;
472: }
473: cluster=get_cluster(inode,*ppos>>clustersize_bits);
474: if(cluster<=0)
475: { printk(KERN_ERR "DMSDOS: write_file: something wrong, cannot happen\n");
476: ret=-EIO;
477: break;
478: }
479: ch=ch_read(sb,cluster,C_KEEP_LOCK|C_NO_READ);
480: if(ch==NULL)
481: { printk(KERN_ERR "DMSDOS: write_file: ch_noread failed\n");
482: ret=-EIO;
483: break;
484: }
485: /*lock_ch(ch); we called with KEEP_LOCK above */
486: ch->c_length=SECTOR_SIZE;
487: }
488: else need_cluster=1;
489: offset=0;
490: }
491: }
492:
493: /* check whether there's a rest to be written */
494: if(offset)
495: { /*unlock_ch(ch);*/
496: /* ch_dirty_locked unlocks the cluster *after* write */
497: if(ch_dirty_locked(ch,0,uc)<0)
498: { printk(KERN_ERR "DMSDOS: write_file: ch_dirty failed!\n");
499: if(ret==0)ret=-EIO;
500: }
501: }
502:
503: if(ch)ch_free(ch);
504:
505: if(*ppos>inode->i_size)
506: { inode->i_size=*ppos;
507: /*inode->i_dirt=1; .... HMMM .... */
508: mark_inode_dirty(inode);
509: }
510:
511: return (written==0)?ret:written;
512: }
513:
514:
515: /* Grmpf.... partially untested code. Don't know an application that does
516: writable mmaps, but it would be needed for testing this piece of code */
517:
518: /* idea: kernel does buffer reads with bmap calculated buffers - impossible
519: for dmsdos. (see kernel mmap code).
520: kernel emulates writable mmap by calling file_write when no buffers
521: are present - should work for dmsdos.
522: so we do file_read-emulated readable mmaps here though the
523: generic_mmap function is used.
524: */
525:
526: #ifdef DMSDOS_USE_READPAGE
527: int read_the_page(unsigned long address, unsigned long pos,
528: struct inode*inode)
529: {
530: unsigned int clear;
531: long gap; /* distance from eof to pos */
532:
533: LOG_FS("DMSDOS: read_the_page\n");
534:
535: address &= PAGE_MASK;
536:
537: clear = 0;
538: gap = inode->i_size - pos;
539: if (gap <= 0){
540: /* mmaping beyond end of file */
541: clear = PAGE_SIZE;
542: }else{
543: int cur_read;
544: int need_read;
545: struct file filp;
546: if (gap < PAGE_SIZE){
547: clear = PAGE_SIZE - gap;
548: }
549: filp.f_reada = 0;
550: filp.f_pos = pos;
551: need_read = PAGE_SIZE - clear;
552: { mm_segment_t cur_fs = get_fs();
553: filp.f_dentry=kmalloc(sizeof(struct dentry),GFP_KERNEL);
554: if(filp.f_dentry==NULL)
555: { printk(KERN_ERR "DMSDOS: read_the_page: no memory!\n");
556: return -1;
557: }
558: filp.f_dentry->d_inode=inode;
559:
560: set_fs (KERNEL_DS);
561: LOG_FS("DMSDOS: read_the_page: calling file_read...\n");
562: cur_read = dblspace_file_read (&filp,
563: (char*)address,
564: need_read,
565: &(filp.f_pos));
566: set_fs (cur_fs);
567: kfree(filp.f_dentry);
568: }
569: if (cur_read != need_read){
570: printk ("DMSDOS: Error while reading an mmap file %d <> %d\n"
571: ,cur_read,need_read);
572: return -1;
573: }
574: }
575: if (clear > 0){
576: memset ((char*)address+PAGE_SIZE-clear,0,clear);
577: }
578: return 0;
579: }
580:
581: #ifdef READPAGE_DENTRY
582: int dblspace_readpage(struct dentry*dentry, struct page *page)
583: { unsigned long address;
584: int error = -1;
585: struct inode*inode=dentry->d_inode;
586: #else
587: int dblspace_readpage(struct inode *inode, struct page *page)
588: { unsigned long address;
589: int error = -1;
590: #endif
591: LOG_FS("DMSDOS: readpage %08lx\n", page_address(page));
592:
593: address = page_address(page);
594: atomic_inc(&page->count);
595: set_bit(PG_locked, &page->flags);
596:
597: /* now read the data */
598: error=read_the_page(address,page->offset,inode);
599:
600: LOG_FS("DMSDOS: readpage: read_the_page returned %d\n",error);
601:
602: if(error==0)set_bit(PG_uptodate, &page->flags);
603:
604: clear_bit(PG_locked, &page->flags);
605: wake_up(&page->wait);
606:
607: free_page(address);
608: return error;
609: }
610:
611: #else /* from: ifdef DMSDOS_USE_READPAGE */
612:
613: /* this is supposed to be obsolete stuff for older kernels... */
614:
615: #if LINUX_VERSION_CODE >= LVC(2,1,90)
616: #error kernel >=2.1.90 requires readpage interface, rerun dmsdos configuration
617: #endif
618:
619: /*
620: * Fill in the supplied page for mmap
621: */
622: static unsigned long dblspace_file_mmap_nopage(
623: struct vm_area_struct * area,
624: unsigned long address,
625: int error_code)
626: {
627: struct inode * inode = area->vm_dentry->d_inode;
628: unsigned long page;
629: unsigned int clear;
630: int pos;
631: long gap; /* distance from eof to pos */
632:
633: LOG_FS("DMSDOS: file_mmap_nopage\n");
634: page = __get_free_page(GFP_KERNEL);
635: if (!page)return page;
636: LOG_FS("DMSDOS: file_mmap_nopage: got page\n");
637:
638: address &= PAGE_MASK;
639: pos = address - area->vm_start + area->vm_offset;
640:
641: clear = 0;
642: gap = inode->i_size - pos;
643: if (gap <= 0){
644: /* mmaping beyond end of file */
645: clear = PAGE_SIZE;
646: }else{
647: int cur_read;
648: int need_read;
649: struct file filp;
650: if (gap < PAGE_SIZE){
651: clear = PAGE_SIZE - gap;
652: }
653: filp.f_reada = 0;
654: filp.f_pos = pos;
655: need_read = PAGE_SIZE - clear;
656: { mm_segment_t cur_fs = get_fs();
657: filp.f_dentry=kmalloc(sizeof(struct dentry),GFP_KERNEL);
658: if(filp.f_dentry==NULL)
659: { printk(KERN_ERR "DMSDOS: file_mmap_nopage: no memory!\n");
660: return -1;
661: }
662: filp.f_dentry->d_inode=inode;
663:
664: set_fs (KERNEL_DS);
665: LOG_FS("DMSDOS: file_mmap_nopage: calling file_read...\n");
666: cur_read = dblspace_file_read (&filp,(char*)page,
667: need_read,&filp.f_pos);
668: LOG_FS("DMSDOS: file_mmap_nopage: file_read returned\n");
669: set_fs (cur_fs);
670: kfree(filp.f_dentry);
671: }
672: if (cur_read != need_read){
673: printk ("DMSDOS: Error while reading an mmap file %d <> %d\n"
674: ,cur_read,need_read);
675: }
676: }
677: if (clear > 0){
678: memset ((char*)page+PAGE_SIZE-clear,0,clear);
679: }
680: LOG_FS("DMSDOS: file_mmap_nopage: end\n");
681: return page;
682: }
683:
684: struct vm_operations_struct dblspace_file_mmap = {
685: NULL, /* open */
686: NULL, /* close */
687: NULL, /* unmap */
688: NULL, /* protect */
689: NULL, /* sync */
690: NULL, /* advise */
691: dblspace_file_mmap_nopage, /* nopage */
692: NULL, /* wppage */
693: NULL, /* swapout */
694: NULL, /* swapin */
695: };
696:
697: /*
698: * This is used for a general mmap of a dmsdos file
699: * Returns 0 if ok, or a negative error code if not.
700: */
701: int dblspace_mmap(struct file*file,struct vm_area_struct*vma)
702: { struct inode *inode = file->f_dentry->d_inode;
703: LOG_FS("DMSDOS: mmap ino=%ld\n",inode->i_ino);
704: if (vma->vm_flags & VM_SHARED) /* only PAGE_COW or read-only supported now */
705: return -EINVAL;
706: if (vma->vm_offset & (inode->i_sb->s_blocksize - 1))
707: return -EINVAL;
708: if (!inode->i_sb || !S_ISREG(inode->i_mode))
709: return -EACCES;
710: if (!IS_RDONLY(inode)) {
711: inode->i_atime = CURRENT_TIME;
712: /*inode->i_dirt = 1;*/
713: mark_inode_dirty(inode);
714: }
715:
716: vma->vm_dentry = dget(file->f_dentry);
717: vma->vm_ops = &dblspace_file_mmap;
718: return 0;
719: }
720:
721: #endif /* from: else / ifdef DMSDOS_USE_READPAGE */
722:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.