![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cvf.diff-2.0.33 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GPL Stacker compression] / dmsdos / patches|
Return to cvf.diff-2.0.33 CVS log | Up to [GPL Stacker compression] / dmsdos / patches |
1.1 root 1: diff -u -r -N linux-2.0.33-cyrix-patched/Documentation/filesystems/fat_cvf.txt linux-2.0.33-cyrix-patched-test/Documentation/filesystems/fat_cvf.txt
2: --- linux-2.0.33-cyrix-patched/Documentation/filesystems/fat_cvf.txt Thu Jan 1 01:00:00 1970
3: +++ linux-2.0.33-cyrix-patched-test/Documentation/filesystems/fat_cvf.txt Wed Nov 18 20:40:50 1998
4: @@ -0,0 +1,210 @@
5: +This is the main documentation for the CVF-FAT filesystem extension. 18Nov1998
6: +
7: +
8: +Table of Contents:
9: +
10: +1. The idea of CVF-FAT
11: +2. Restrictions
12: +3. Mount options
13: +4. Description of the CVF-FAT interface
14: +5. CVF Modules
15: +
16: +------------------------------------------------------------------------------
17: +
18: +
19: +1. The idea of CVF-FAT
20: +------------------------------------------------------------------------------
21: +
22: +CVF-FAT is a FAT filesystem extension that provides a generic interface for
23: +Compressed Volume Files in FAT partitions. Popular CVF software, for
24: +example, are Microsoft's Doublespace/Drivespace and Stac's Stacker.
25: +Using the CVF-FAT interface, it is possible to load a module that handles
26: +all the low-level disk access that has to do with on-the-fly compression
27: +and decompression. Any other part of FAT filesystem access is still handled
28: +by the FAT, MSDOS or VFAT or even UMSDOS driver.
29: +
30: +CVF access works by redirecting certain low-level routines from the FAT
31: +driver to a loadable, CVF-format specific module. This module must fake
32: +a normal FAT filesystem to the FAT driver while doing all the extra stuff
33: +like compression and decompression silently.
34: +
35: +
36: +2. Restrictions
37: +------------------------------------------------------------------------------
38: +
39: +- BMAP problems
40: +
41: + CVF filesystems cannot do bmap. It's impossible in principle. Thus
42: + all actions that require bmap do not work (swapping, writable mmapping).
43: + Read-only mmapping works because the FAT driver has a hack for this
44: + situation :) Well, writable mmapping should now work using the readpage
45: + interface function which has been hacked into the FAT driver just for
46: + CVF-FAT :)
47: +
48: +- attention, DOSEmu users
49: +
50: + You may have to unmount all CVF partitions before running DOSEmu depending
51: + on your configuration. If DOSEmu is configured to use wholedisk or
52: + partition access (this is often the case to let DOSEmu access
53: + compressed partitions) there's a risk of destroying your compressed
54: + partitions or crashing your system because of confused drivers.
55: +
56: + Note that it is always safe to redirect the compressed partitions with
57: + lredir or emufs.sys. Refer to the DOSEmu documentation for details.
58: +
59: +
60: +3. Mount options
61: +------------------------------------------------------------------------------
62: +
63: +The CVF-FAT extension currently adds the following options to the FAT
64: +driver's standard options:
65: +
66: + cvf_format=xxx
67: + Forces the driver to use the CVF module "xxx" instead of auto-detection.
68: + Without this option, the CVF-FAT interface asks all currently loaded
69: + CVF modules whether they recognize the CVF. Therefore, this option is
70: + only necessary if the CVF format is not recognized correctly
71: + because of bugs or incompatibilities in the CVF modules. (It skips
72: + the detect_cvf call.) "xxx" may be the text "none" (without the quotes)
73: + to inhibit using any of the loaded CVF modules, just in case a CVF
74: + module insists on mounting plain FAT filesystems by misunderstanding.
75: + "xxx" may also be the text "autoload", which has a special meaning for
76: + kerneld, but does not skip auto-detection.
77: +
78: + If the kernel supports kerneld, the cvf_format=xxx option also controls
79: + on-demand CVF module loading. Without this option, nothing is loaded
80: + on demand. With cvf_format=xxx, a module "xxx" is requested automatically
81: + before mounting the compressed filesystem (unless "xxx" is "none"). In
82: + case there is a difference between the CVF format name and the module
83: + name, setup aliases in your kerneld configuration. If the string "xxx"
84: + is "autoload", a non-existent module "cvf_autoload" is requested which
85: + can be used together with a special kerneld configuration (alias and
86: + pre-install statements) in order to load more than one CVF module, let
87: + them detect automatically which kind of CVF is to be mounted, and only
88: + keep the "right" module in memory. For examples please refer to the
89: + dmsdos documentation (ftp and http addresses see below).
90: +
91: + cvf_options=yyy
92: + Option string passed to the CVF module. I.e. only the "yyy" is passed
93: + (without the quotes). The documentation for each CVF module should
94: + explain it since it is interpreted only by the CVF module. Note that
95: + the string must not contain a comma (",") - this would lead to
96: + misinterpretation by the FAT driver, which would recognize the text
97: + after a comma as a FAT driver option and might get confused or print
98: + strange error messages. The documentation for the CVF module should
99: + offer a different separation symbol, for example the dot "." or the
100: + plus sign "+", which is only valid inside the string "yyy".
101: +
102: +
103: +4. Description of the CVF-FAT interface
104: +------------------------------------------------------------------------------
105: +
106: +Assuming you want to write your own CVF module, you need to write a lot of
107: +interface functions. Most of them are covered in the kernel documentation
108: +you can find on the net, and thus won't be described here. They have been
109: +marked with "[...]" :-) Take a look at include/linux/fat_cvf.h.
110: +
111: +struct cvf_format
112: +{ int cvf_version;
113: + char* cvf_version_text;
114: + unsigned long int flags;
115: + int (*detect_cvf) (struct super_block*sb);
116: + int (*mount_cvf) (struct super_block*sb,char*options);
117: + int (*unmount_cvf) (struct super_block*sb);
118: + [...]
119: + void (*cvf_zero_cluster) (struct inode*inode,int clusternr);
120: +}
121: +
122: +This structure defines the capabilities of a CVF module. It must be filled
123: +out completely by a CVF module. Consider it as a kind of form that is used
124: +to introduce the module to the FAT/CVF-FAT driver.
125: +
126: +It contains...
127: + - cvf_version:
128: + A version id which must be unique. Choose one.
129: + - cvf_version_text:
130: + A human readable version string that should be one short word
131: + describing the CVF format the module implements. This text is used
132: + for the cvf_format option. This name must also be unique.
133: + - flags:
134: + Bit coded flags, currently only used for a readpage/mmap hack that
135: + provides both mmap and readpage functionality. If CVF_USE_READPAGE
136: + is set, mmap is set to generic_file_mmap and readpage is caught
137: + and redirected to the cvf_readpage function. If it is not set,
138: + readpage is set to generic_readpage and mmap is caught and redirected
139: + to cvf_mmap. (If you want writable mmap use the readpage interface.)
140: + - detect_cvf:
141: + A function that is called to decide whether the filesystem is a CVF of
142: + the type the module supports. The detect_cvf function must return 0
143: + for "NO, I DON'T KNOW THIS GARBAGE" or anything >0 for "YES, THIS IS
144: + THE KIND OF CVF I SUPPORT". The function must maintain the module
145: + usage counters for safety, i.e. do MOD_INC_USE_COUNT at the beginning
146: + and MOD_DEC_USE_COUNT at the end. The function *must not* assume that
147: + successful recongition would lead to a call of the mount_cvf function
148: + later.
149: + - mount_cvf:
150: + A function that sets up some values or initializes something additional
151: + to what has to be done when a CVF is mounted. This is called at the
152: + end of fat_read_super and must return 0 on success. Definitely, this
153: + function must increment the module usage counter by MOD_INC_USE_COUNT.
154: + This mount_cvf function is also responsible for interpreting a CVF
155: + module specific option string (the "yyy" from the FAT mount option
156: + "cvf_options=yyy") which cannot contain a comma (use for example the
157: + dot "." as option separator symbol).
158: + - unmount_cvf:
159: + A function that is called when the filesystem is unmounted. Most likely
160: + it only frees up some memory and calls MOD_DEC_USE_COUNT. The return
161: + value might be ignored (it currently is ignored).
162: + - [...]:
163: + All other interface functions are "caught" FAT driver functions, i.e.
164: + are executed by the FAT driver *instead* of the original FAT driver
165: + functions. NULL means use the original FAT driver functions instead.
166: + If you really want "no action", write a function that does nothing and
167: + hang it in instead.
168: + - cvf_zero_cluster:
169: + The cvf_zero_cluster function is called when the fat driver wants to
170: + zero out a (new) cluster. This is important for directories (mkdir).
171: + If it is NULL, the FAT driver defaults to overwriting the whole
172: + cluster with zeros. Note that clusternr is absolute, not relative
173: + to the provided inode.
174: +
175: +Notes:
176: + 1. The cvf_bmap function should be ignored. It really should never
177: + get called from somewhere. I recommend redirecting it to a panic
178: + or fatal error message so bugs show up immediately.
179: + 2. The cvf_writepage function is ignored. This is because the fat
180: + driver doesn't support it. This might change in future. I recommend
181: + setting it to NULL (i.e use default).
182: +
183: +int register_cvf_format(struct cvf_format*cvf_format);
184: + If you have just set up a variable containing the above structure,
185: + call this function to introduce your CVF format to the FAT/CVF-FAT
186: + driver. This is usually done in init_module. Be sure to check the
187: + return value. Zero means success, everything else causes a kernel
188: + message printed in the syslog describing the error that occurred.
189: + Typical errors are:
190: + - a module with the same version id is already registered or
191: + - too many CVF formats. Hack fs/fat/cvf.c if you need more.
192: +
193: +int unregister_cvf_format(struct cvf_format*cvf_format);
194: + This is usually called in cleanup_module. Return value =0 means
195: + success. An error only occurs if you try to unregister a CVF format
196: + that has not been previously registered. The code uses the version id
197: + to distinguish the modules, so be sure to keep it unique.
198: +
199: +5. CVF Modules
200: +------------------------------------------------------------------------------
201: +
202: +Refer to the dmsdos module (the successor of the dmsdos filesystem) for a
203: +sample implementation. It can currently be found at
204: +
205: + ftp://fb9nt.uni-duisburg.de/pub/linux/dmsdos/dmsdos-x.y.z.tgz
206: + ftp://sunsite.unc.edu/pub/Linux/system/Filesystems/dosfs/dmsdos-x.y.z.tgz
207: + ftp://ftp.uni-stuttgart.de/pub/systems/linux/local/system/dmsdos-x.y.z.tgz
208: +
209: +(where x.y.z is to be replaced with the actual version number). Full
210: +documentation about dmsdos is included in the dmsdos package, but can also
211: +be found at
212: +
213: + http://fb9nt.uni-duisburg.de/mitarbeiter/gockel/software/dmsdos/index.html
214: + http://www.yk.rim.or.jp/~takafumi/dmsdos/index.html (in Japanese).
215: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/Makefile linux-2.0.33-cyrix-patched-test/fs/fat/Makefile
216: --- linux-2.0.33-cyrix-patched/fs/fat/Makefile Wed Feb 7 08:39:27 1996
217: +++ linux-2.0.33-cyrix-patched-test/fs/fat/Makefile Sat Dec 27 21:34:20 1997
218: @@ -8,7 +8,7 @@
219: # Note 2! The CFLAGS definitions are now in the main makefile...
220:
221: O_TARGET := fat.o
222: -O_OBJS := buffer.o cache.o dir.o file.o inode.o misc.o mmap.o tables.o
223: +O_OBJS := buffer.o cache.o dir.o file.o inode.o misc.o mmap.o tables.o cvf.o
224: OX_OBJS := fatfs_syms.o
225: M_OBJS := $(O_TARGET)
226:
227: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/buffer.c linux-2.0.33-cyrix-patched-test/fs/fat/buffer.c
228: --- linux-2.0.33-cyrix-patched/fs/fat/buffer.c Fri May 10 06:54:52 1996
229: +++ linux-2.0.33-cyrix-patched-test/fs/fat/buffer.c Sat Dec 27 21:46:10 1997
230: @@ -9,6 +9,7 @@
231: #include <linux/string.h>
232: #include <linux/fs.h>
233: #include <linux/msdos_fs.h>
234: +#include <linux/fat_cvf.h>
235:
236: struct buffer_head *fat_bread (
237: struct super_block *sb,
238: @@ -16,6 +17,10 @@
239: {
240: struct buffer_head *ret = NULL;
241:
242: + if(MSDOS_SB(sb)->cvf_format)
243: + if(MSDOS_SB(sb)->cvf_format->cvf_bread)
244: + return MSDOS_SB(sb)->cvf_format->cvf_bread(sb,block);
245: +
246: /* Note that the blocksize is 512 or 1024, but the first read
247: is always of size 1024. Doing readahead may be counterproductive
248: or just plain wrong. */
249: @@ -73,6 +78,11 @@
250: int block)
251: {
252: struct buffer_head *ret = NULL;
253: +
254: + if(MSDOS_SB(sb)->cvf_format)
255: + if(MSDOS_SB(sb)->cvf_format->cvf_getblk)
256: + return MSDOS_SB(sb)->cvf_format->cvf_getblk(sb,block);
257: +
258: if (sb->s_blocksize == 512){
259: ret = getblk (sb->s_dev,block,512);
260: }else{
261: @@ -92,6 +102,10 @@
262: struct buffer_head *bh)
263: {
264: if (bh != NULL){
265: + if(MSDOS_SB(sb)->cvf_format)
266: + if(MSDOS_SB(sb)->cvf_format->cvf_brelse)
267: + return MSDOS_SB(sb)->cvf_format->cvf_brelse(sb,bh);
268: +
269: if (sb->s_blocksize == 512){
270: brelse (bh);
271: }else{
272: @@ -109,6 +123,12 @@
273: struct buffer_head *bh,
274: int dirty_val)
275: {
276: + if(MSDOS_SB(sb)->cvf_format)
277: + if(MSDOS_SB(sb)->cvf_format->cvf_mark_buffer_dirty)
278: + { MSDOS_SB(sb)->cvf_format->cvf_mark_buffer_dirty(sb,bh,dirty_val);
279: + return;
280: + }
281: +
282: if (sb->s_blocksize != 512){
283: bh = bh->b_next;
284: }
285: @@ -120,6 +140,12 @@
286: struct buffer_head *bh,
287: int val)
288: {
289: + if(MSDOS_SB(sb)->cvf_format)
290: + if(MSDOS_SB(sb)->cvf_format->cvf_set_uptodate)
291: + { MSDOS_SB(sb)->cvf_format->cvf_set_uptodate(sb,bh,val);
292: + return;
293: + }
294: +
295: if (sb->s_blocksize != 512){
296: bh = bh->b_next;
297: }
298: @@ -129,6 +155,10 @@
299: struct super_block *sb,
300: struct buffer_head *bh)
301: {
302: + if(MSDOS_SB(sb)->cvf_format)
303: + if(MSDOS_SB(sb)->cvf_format->cvf_is_uptodate)
304: + return MSDOS_SB(sb)->cvf_format->cvf_is_uptodate(sb,bh);
305: +
306: if (sb->s_blocksize != 512){
307: bh = bh->b_next;
308: }
309: @@ -141,6 +171,12 @@
310: int nbreq,
311: struct buffer_head *bh[32])
312: {
313: + if(MSDOS_SB(sb)->cvf_format)
314: + if(MSDOS_SB(sb)->cvf_format->cvf_ll_rw_block)
315: + { MSDOS_SB(sb)->cvf_format->cvf_ll_rw_block(sb,opr,nbreq,bh);
316: + return;
317: + }
318: +
319: if (sb->s_blocksize == 512){
320: ll_rw_block(opr,nbreq,bh);
321: }else{
322: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/cache.c linux-2.0.33-cyrix-patched-test/fs/fat/cache.c
323: --- linux-2.0.33-cyrix-patched/fs/fat/cache.c Fri May 10 06:54:52 1996
324: +++ linux-2.0.33-cyrix-patched-test/fs/fat/cache.c Sun Dec 28 12:16:08 1997
325: @@ -9,6 +9,7 @@
326: #include <linux/errno.h>
327: #include <linux/string.h>
328: #include <linux/stat.h>
329: +#include <linux/fat_cvf.h>
330:
331: #include "msbuffer.h"
332:
333: @@ -24,6 +25,10 @@
334: unsigned char *p_first,*p_last;
335: int first,last,next,copy,b;
336:
337: + if(MSDOS_SB(sb)->cvf_format)
338: + if(MSDOS_SB(sb)->cvf_format->fat_access)
339: + return MSDOS_SB(sb)->cvf_format->fat_access(sb,nr,new_value);
340: +
341: if ((unsigned) (nr-2) >= MSDOS_SB(sb)->clusters)
342: return 0;
343: if (MSDOS_SB(sb)->fat_bits == 16) {
344: @@ -246,6 +251,10 @@
345: int cluster,offset;
346:
347: sb = MSDOS_SB(inode->i_sb);
348: + if(sb->cvf_format)
349: + if(sb->cvf_format->cvf_smap)
350: + return sb->cvf_format->cvf_smap(inode,sector);
351: +
352: if (inode->i_ino == MSDOS_ROOT_INO || (S_ISDIR(inode->i_mode) &&
353: !MSDOS_I(inode)->i_start)) {
354: if (sector >= sb->dir_entries >> MSDOS_DPS_BITS) return 0;
355: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/cvf.c linux-2.0.33-cyrix-patched-test/fs/fat/cvf.c
356: --- linux-2.0.33-cyrix-patched/fs/fat/cvf.c Thu Jan 1 01:00:00 1970
357: +++ linux-2.0.33-cyrix-patched-test/fs/fat/cvf.c Tue Nov 17 20:10:41 1998
358: @@ -0,0 +1,147 @@
359: +/*
360: + * CVF extensions for fat-based filesystems
361: + *
362: + * written 1997,1998 by Frank Gockel <[email protected]>
363: + *
364: + * please do not remove the next line, dmsdos needs it for verifying patches
365: + * CVF-FAT-VERSION-ID: 1.1.0
366: + *
367: + */
368: +
369: +#include<linux/sched.h>
370: +#include<linux/fs.h>
371: +#include<linux/msdos_fs.h>
372: +#include<linux/msdos_fs_sb.h>
373: +#include<linux/string.h>
374: +#include<linux/fat_cvf.h>
375: +#include<linux/config.h>
376: +#ifdef CONFIG_KERNELD
377: +#include<linux/kerneld.h>
378: +#endif
379: +
380: +#define MAX_CVF_FORMATS 3
381: +
382: +struct cvf_format *cvf_formats[MAX_CVF_FORMATS]={NULL,NULL,NULL};
383: +int cvf_format_use_count[MAX_CVF_FORMATS]={0,0,0};
384: +
385: +int register_cvf_format(struct cvf_format*cvf_format)
386: +{ int i,j;
387: +
388: + for(i=0;i<MAX_CVF_FORMATS;++i)
389: + { if(cvf_formats[i]==NULL)
390: + { /* free slot found, now check version */
391: + for(j=0;j<MAX_CVF_FORMATS;++j)
392: + { if(cvf_formats[j])
393: + { if(cvf_formats[j]->cvf_version==cvf_format->cvf_version)
394: + { printk("register_cvf_format: version %d already registered\n",
395: + cvf_format->cvf_version);
396: + return -1;
397: + }
398: + }
399: + }
400: + cvf_formats[i]=cvf_format;
401: + cvf_format_use_count[i]=0;
402: + printk("CVF format %s (version id %d) successfully registered.\n",
403: + cvf_format->cvf_version_text,cvf_format->cvf_version);
404: + return 0;
405: + }
406: + }
407: +
408: + printk("register_cvf_format: too many formats\n");
409: + return -1;
410: +}
411: +
412: +int unregister_cvf_format(struct cvf_format*cvf_format)
413: +{ int i;
414: +
415: + for(i=0;i<MAX_CVF_FORMATS;++i)
416: + { if(cvf_formats[i])
417: + { if(cvf_formats[i]->cvf_version==cvf_format->cvf_version)
418: + { if(cvf_format_use_count[i])
419: + { printk("unregister_cvf_format: format %d in use, cannot remove!\n",
420: + cvf_formats[i]->cvf_version);
421: + return -1;
422: + }
423: +
424: + printk("CVF format %s (version id %d) successfully unregistered.\n",
425: + cvf_formats[i]->cvf_version_text,cvf_formats[i]->cvf_version);
426: + cvf_formats[i]=NULL;
427: + return 0;
428: + }
429: + }
430: + }
431: +
432: + printk("unregister_cvf_format: format %d is not registered\n",
433: + cvf_format->cvf_version);
434: + return -1;
435: +}
436: +
437: +void dec_cvf_format_use_count_by_version(int version)
438: +{ int i;
439: +
440: + for(i=0;i<MAX_CVF_FORMATS;++i)
441: + { if(cvf_formats[i])
442: + { if(cvf_formats[i]->cvf_version==version)
443: + { --cvf_format_use_count[i];
444: + if(cvf_format_use_count[i]<0)
445: + { cvf_format_use_count[i]=0;
446: + printk(KERN_EMERG "FAT FS/CVF: This is a bug in cvf_version_use_count\n");
447: + }
448: + return;
449: + }
450: + }
451: + }
452: +
453: + printk("dec_cvf_format_use_count_by_version: version %d not found ???\n",
454: + version);
455: +}
456: +
457: +int detect_cvf(struct super_block*sb,char*force)
458: +{ int i;
459: + int found=0;
460: + int found_i=-1;
461: +
462: + if(force)
463: + if(strcmp(force,"autoload")==0)
464: + {
465: +#ifdef CONFIG_KERNELD
466: + request_module("cvf_autoload");
467: + force=NULL;
468: +#else
469: + printk("cannot autoload CVF modules: kerneld support is not compiled into kernel\n");
470: + return -1;
471: +#endif
472: + }
473: +
474: +#ifdef CONFIG_KERNELD
475: + if(force)
476: + if(*force)
477: + request_module(force);
478: +#endif
479: +
480: + if(force)
481: + { if(*force)
482: + { for(i=0;i<MAX_CVF_FORMATS;++i)
483: + { if(cvf_formats[i])
484: + { if(!strcmp(cvf_formats[i]->cvf_version_text,force))
485: + return i;
486: + }
487: + }
488: + printk("CVF format %s unknown (module not loaded?)\n",force);
489: + return -1;
490: + }
491: + }
492: +
493: + for(i=0;i<MAX_CVF_FORMATS;++i)
494: + { if(cvf_formats[i])
495: + { if(cvf_formats[i]->detect_cvf(sb))
496: + { ++found;
497: + found_i=i;
498: + }
499: + }
500: + }
501: +
502: + if(found==1)return found_i;
503: + if(found>1)printk("CVF detection ambiguous, please use cvf_format=xxx option\n");
504: + return -1;
505: +}
506: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/dir.c linux-2.0.33-cyrix-patched-test/fs/fat/dir.c
507: --- linux-2.0.33-cyrix-patched/fs/fat/dir.c Fri May 10 06:54:52 1996
508: +++ linux-2.0.33-cyrix-patched-test/fs/fat/dir.c Sat Jan 3 12:41:00 1998
509: @@ -382,6 +382,7 @@
510: unsigned int cmd, unsigned long arg)
511: {
512: int err;
513: +
514: /*
515: * We want to provide an interface for Samba to be able
516: * to get the short filename for a given long filename.
517: @@ -408,6 +409,11 @@
518: vfat_ioctl_fill, NULL, 1, 0, 1);
519: }
520: default:
521: + /* forward ioctl to CVF extension */
522: + if(MSDOS_SB(inode->i_sb)->cvf_format
523: + &&MSDOS_SB(inode->i_sb)->cvf_format->cvf_dir_ioctl)
524: + return MSDOS_SB(inode->i_sb)->cvf_format->
525: + cvf_dir_ioctl(inode,filp,cmd,arg);
526: return -EINVAL;
527: }
528:
529: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/fatfs_syms.c linux-2.0.33-cyrix-patched-test/fs/fat/fatfs_syms.c
530: --- linux-2.0.33-cyrix-patched/fs/fat/fatfs_syms.c Tue Mar 5 12:03:26 1996
531: +++ linux-2.0.33-cyrix-patched-test/fs/fat/fatfs_syms.c Sat Jan 3 10:41:33 1998
532: @@ -8,6 +8,7 @@
533:
534: #include <linux/mm.h>
535: #include <linux/msdos_fs.h>
536: +#include <linux/fat_cvf.h>
537:
538: #include "msbuffer.h"
539: #include "tables.h"
540: @@ -48,6 +49,13 @@
541: X(fat_uni2code),
542: X(fat_unlock_creation),
543: X(fat_write_inode),
544: + X(register_cvf_format),
545: + X(unregister_cvf_format),
546: + X(get_cluster),
547: + X(lock_fat),
548: + X(unlock_fat),
549: + X(fat_readpage),
550: + X(fat_dir_ioctl),
551: #include <linux/symtab_end.h>
552: };
553:
554: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/file.c linux-2.0.33-cyrix-patched-test/fs/fat/file.c
555: --- linux-2.0.33-cyrix-patched/fs/fat/file.c Fri May 10 06:54:52 1996
556: +++ linux-2.0.33-cyrix-patched-test/fs/fat/file.c Fri Jan 2 20:24:15 1998
557: @@ -15,6 +15,7 @@
558: #include <linux/stat.h>
559: #include <linux/string.h>
560: #include <linux/pagemap.h>
561: +#include <linux/fat_cvf.h>
562:
563: #include <asm/segment.h>
564: #include <asm/system.h>
565: @@ -109,6 +110,40 @@
566: NULL /* smap */
567: };
568:
569: +static struct file_operations fat_file_operations_readpage = {
570: + NULL, /* lseek - default */
571: + fat_file_read, /* read */
572: + fat_file_write, /* write */
573: + NULL, /* readdir - bad */
574: + NULL, /* select - default */
575: + NULL, /* ioctl - default */
576: + generic_file_mmap, /* mmap */
577: + NULL, /* no special open is needed */
578: + NULL, /* release */
579: + file_fsync /* fsync */
580: +};
581: +
582: +struct inode_operations fat_file_inode_operations_readpage = {
583: + &fat_file_operations_readpage, /* default file operations */
584: + NULL, /* create */
585: + NULL, /* lookup */
586: + NULL, /* link */
587: + NULL, /* unlink */
588: + NULL, /* symlink */
589: + NULL, /* mkdir */
590: + NULL, /* rmdir */
591: + NULL, /* mknod */
592: + NULL, /* rename */
593: + NULL, /* readlink */
594: + NULL, /* follow_link */
595: + fat_readpage, /* readpage */
596: + NULL, /* writepage */
597: + NULL, /* bmap */
598: + fat_truncate, /* truncate */
599: + NULL, /* permission */
600: + NULL /* smap */
601: +};
602: +
603: #define MSDOS_PREFETCH 32
604: struct fat_pre {
605: int file_sector;/* Next sector to read in the prefetch table */
606: @@ -170,6 +205,10 @@
607: printk("fat_file_read: inode = NULL\n");
608: return -EINVAL;
609: }
610: + if(MSDOS_SB(sb)->cvf_format)
611: + if(MSDOS_SB(sb)->cvf_format->cvf_file_read)
612: + return MSDOS_SB(sb)->cvf_format->cvf_file_read(inode,filp,buf,count);
613: +
614: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
615: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
616: printk("fat_file_read: mode = %07o\n",inode->i_mode);
617: @@ -287,6 +326,10 @@
618: printk("fat_file_write: inode = NULL\n");
619: return -EINVAL;
620: }
621: + if(MSDOS_SB(sb)->cvf_format)
622: + if(MSDOS_SB(sb)->cvf_format->cvf_file_write)
623: + return MSDOS_SB(sb)->cvf_format->cvf_file_write(inode,filp,buf,count);
624: +
625: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */
626: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) {
627: printk("fat_file_write: mode = %07o\n",inode->i_mode);
628: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/inode.c linux-2.0.33-cyrix-patched-test/fs/fat/inode.c
629: --- linux-2.0.33-cyrix-patched/fs/fat/inode.c Sat Nov 30 11:27:38 1996
630: +++ linux-2.0.33-cyrix-patched-test/fs/fat/inode.c Sat Jan 3 10:46:27 1998
631: @@ -18,6 +18,8 @@
632: #include <linux/fs.h>
633: #include <linux/stat.h>
634: #include <linux/locks.h>
635: +#include <linux/fat_cvf.h>
636: +#include <linux/malloc.h>
637:
638: #include "msbuffer.h"
639: #include "tables.h"
640: @@ -75,6 +77,10 @@
641:
642: void fat_put_super(struct super_block *sb)
643: {
644: + if(MSDOS_SB(sb)->cvf_format)
645: + { dec_cvf_format_use_count_by_version(MSDOS_SB(sb)->cvf_format->cvf_version);
646: + MSDOS_SB(sb)->cvf_format->unmount_cvf(sb);
647: + }
648: fat_cache_inval_dev(sb->s_dev);
649: set_blocksize (sb->s_dev,BLOCK_SIZE);
650: lock_super(sb);
651: @@ -86,7 +92,8 @@
652:
653:
654: static int parse_options(char *options,int *fat, int *blksize, int *debug,
655: - struct fat_mount_options *opts)
656: + struct fat_mount_options *opts,
657: + char* cvf_format, char*cvf_options)
658: {
659: char *this_char,*value;
660:
661: @@ -181,6 +188,17 @@
662: return 0;
663: opts->sys_immutable = 1;
664: }
665: + else if (!strcmp(this_char,"cvf_format")) {
666: + if (!value)
667: + return 0;
668: + strncpy(cvf_format,value,20);
669: + }
670: + else if (!strcmp(this_char,"cvf_options")) {
671: + if (!value)
672: + return 0;
673: + strncpy(cvf_options,value,100);
674: + }
675: +
676: }
677: return 1;
678: }
679: @@ -196,6 +214,14 @@
680: int debug,error,fat;
681: int blksize = 512;
682: struct fat_mount_options opts;
683: + int i;
684: + char cvf_format[21];
685: + char cvf_options[101];
686: +
687: + cvf_format[0]='\0';
688: + cvf_options[0]='\0';
689: + MSDOS_SB(sb)->cvf_format=NULL;
690: + MSDOS_SB(sb)->private_data=NULL;
691:
692: MOD_INC_USE_COUNT;
693: if (hardsect_size[MAJOR(sb->s_dev)] != NULL){
694: @@ -204,7 +230,7 @@
695: printk ("MSDOS: Hardware sector size is %d\n",blksize);
696: }
697: }
698: - if (!parse_options((char *) data, &fat, &blksize, &debug, &opts)
699: + if (!parse_options((char *) data, &fat, &blksize, &debug, &opts, cvf_format, cvf_options)
700: || (blksize != 512 && blksize != 1024)) {
701: sb->s_dev = 0;
702: MOD_DEC_USE_COUNT;
703: @@ -286,6 +312,9 @@
704: /* because clusters (DOS) are often aligned */
705: /* on odd sectors. */
706: sb->s_blocksize_bits = blksize == 512 ? 9 : 10;
707: + if(!strcmp(cvf_format,"none"))i=-1;
708: + else i=detect_cvf(sb,cvf_format);
709: + if(i>=0)error=cvf_formats[i]->mount_cvf(sb,cvf_options);
710: if (error || debug) {
711: /* The MSDOS_CAN_BMAP is obsolete, but left just to remember */
712: printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c,"
713: @@ -302,13 +331,15 @@
714: (unsigned long)b->total_sect,logical_sector_size);
715: printk ("Transaction block size = %d\n",blksize);
716: }
717: - if (MSDOS_SB(sb)->clusters+2 > fat_clusters)
718: + if(i<0) if (MSDOS_SB(sb)->clusters+2 > fat_clusters)
719: MSDOS_SB(sb)->clusters = fat_clusters-2;
720: if (error) {
721: if (!silent)
722: printk("VFS: Can't find a valid MSDOS filesystem on dev "
723: "%s.\n", kdevname(sb->s_dev));
724: sb->s_dev = 0;
725: + if(MSDOS_SB(sb)->private_data)kfree(MSDOS_SB(sb)->private_data);
726: + MSDOS_SB(sb)->private_data=NULL;
727: MOD_DEC_USE_COUNT;
728: return NULL;
729: }
730: @@ -321,10 +352,16 @@
731: memcpy(&(MSDOS_SB(sb)->options), &opts, sizeof(struct fat_mount_options));
732: if (!(sb->s_mounted = iget(sb,MSDOS_ROOT_INO))) {
733: sb->s_dev = 0;
734: + if(MSDOS_SB(sb)->private_data)kfree(MSDOS_SB(sb)->private_data);
735: + MSDOS_SB(sb)->private_data=NULL;
736: printk("get root inode failed\n");
737: MOD_DEC_USE_COUNT;
738: return NULL;
739: }
740: + if(i>=0)
741: + { MSDOS_SB(sb)->cvf_format=cvf_formats[i];
742: + ++cvf_format_use_count[i];
743: + }
744: return sb;
745: }
746:
747: @@ -333,7 +370,13 @@
748: {
749: int free,nr;
750: struct statfs tmp;
751: -
752: +
753: + if(MSDOS_SB(sb)->cvf_format)
754: + if(MSDOS_SB(sb)->cvf_format->cvf_statfs)
755: + { MSDOS_SB(sb)->cvf_format->cvf_statfs(sb,buf,bufsiz);
756: + return;
757: + }
758: +
759: lock_fat(sb);
760: if (MSDOS_SB(sb)->free_clusters != -1)
761: free = MSDOS_SB(sb)->free_clusters;
762: @@ -362,6 +405,10 @@
763: int cluster,offset;
764:
765: sb = MSDOS_SB(inode->i_sb);
766: + if(sb->cvf_format)
767: + if(sb->cvf_format->cvf_bmap)
768: + return sb->cvf_format->cvf_bmap(inode,block);
769: +
770: if (inode->i_ino == MSDOS_ROOT_INO) {
771: return sb->dir_start + block;
772: }
773: @@ -451,7 +498,12 @@
774: !is_exec(raw_entry->ext)))
775: ? S_IRUGO|S_IWUGO : S_IRWXUGO)
776: & ~MSDOS_SB(sb)->options.fs_umask) | S_IFREG;
777: - inode->i_op = (sb->s_blocksize == 1024)
778: + if(MSDOS_SB(sb)->cvf_format)
779: + inode->i_op = (MSDOS_SB(sb)->cvf_format->flags&CVF_USE_READPAGE)
780: + ? &fat_file_inode_operations_readpage
781: + : &fat_file_inode_operations_1024;
782: + else
783: + inode->i_op = (sb->s_blocksize == 1024)
784: ? &fat_file_inode_operations_1024
785: : &fat_file_inode_operations;
786: MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
787: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/misc.c linux-2.0.33-cyrix-patched-test/fs/fat/misc.c
788: --- linux-2.0.33-cyrix-patched/fs/fat/misc.c Fri May 10 06:54:52 1996
789: +++ linux-2.0.33-cyrix-patched-test/fs/fat/misc.c Fri Jan 2 22:35:54 1998
790: @@ -186,6 +186,10 @@
791: #endif
792: sector = MSDOS_SB(sb)->data_start+(nr-2)*cluster_size;
793: last_sector = sector + cluster_size;
794: + if(MSDOS_SB(sb)->cvf_format&&
795: + MSDOS_SB(sb)->cvf_format->zero_out_cluster)
796: + MSDOS_SB(sb)->cvf_format->zero_out_cluster(inode,nr);
797: + else
798: for ( ; sector < last_sector; sector++) {
799: #ifdef DEBUG
800: printk("zeroing sector %d\n",sector);
801: diff -u -r -N linux-2.0.33-cyrix-patched/fs/fat/mmap.c linux-2.0.33-cyrix-patched-test/fs/fat/mmap.c
802: --- linux-2.0.33-cyrix-patched/fs/fat/mmap.c Fri Feb 9 06:47:16 1996
803: +++ linux-2.0.33-cyrix-patched-test/fs/fat/mmap.c Fri Jan 2 20:15:29 1998
804: @@ -93,6 +93,9 @@
805: */
806: int fat_mmap(struct inode * inode, struct file * file, struct vm_area_struct * vma)
807: {
808: + if(MSDOS_SB(inode->i_sb)->cvf_format)
809: + if(MSDOS_SB(inode->i_sb)->cvf_format->cvf_mmap)
810: + return MSDOS_SB(inode->i_sb)->cvf_format->cvf_mmap(inode,file,vma);
811: if (vma->vm_flags & VM_SHARED) /* only PAGE_COW or read-only supported now */
812: return -EINVAL;
813: if (vma->vm_offset & (inode->i_sb->s_blocksize - 1))
814: @@ -110,4 +113,12 @@
815: return 0;
816: }
817:
818: +int fat_readpage(struct inode * inode, struct page * page)
819: +{
820: + if(MSDOS_SB(inode->i_sb)->cvf_format)
821: + if(MSDOS_SB(inode->i_sb)->cvf_format->cvf_readpage)
822: + return MSDOS_SB(inode->i_sb)->cvf_format->cvf_readpage(inode,page);
823:
824: + printk("fat_readpage called with no handler (shouldn't happen)\n");
825: + return -1;
826: +}
827: diff -u -r -N linux-2.0.33-cyrix-patched/fs/umsdos/emd.c linux-2.0.33-cyrix-patched-test/fs/umsdos/emd.c
828: --- linux-2.0.33-cyrix-patched/fs/umsdos/emd.c Wed Feb 7 08:39:29 1996
829: +++ linux-2.0.33-cyrix-patched-test/fs/umsdos/emd.c Sat Jan 3 19:13:43 1998
830: @@ -32,6 +32,7 @@
831: int ret;
832: int old_fs = get_fs();
833: set_fs (KERNEL_DS);
834: + MSDOS_I(inode)->i_binary=2;
835: ret = fat_file_read(inode,filp,buf,count);
836: set_fs (old_fs);
837: return ret;
838: @@ -48,6 +49,7 @@
839: int ret;
840: int old_fs = get_fs();
841: set_fs (KERNEL_DS);
842: + MSDOS_I(inode)->i_binary=2;
843: ret = fat_file_write(inode,filp,buf,count);
844: set_fs (old_fs);
845: return ret;
846: diff -u -r -N linux-2.0.33-cyrix-patched/fs/umsdos/file.c linux-2.0.33-cyrix-patched-test/fs/umsdos/file.c
847: --- linux-2.0.33-cyrix-patched/fs/umsdos/file.c Tue Feb 20 09:28:13 1996
848: +++ linux-2.0.33-cyrix-patched-test/fs/umsdos/file.c Fri Jan 2 23:50:57 1998
849: @@ -129,3 +129,38 @@
850: NULL, /* smap */
851: };
852:
853: +/* For other with larger and unaligned file system with readpage */
854: +struct file_operations umsdos_file_operations_readpage = {
855: + NULL, /* lseek - default */
856: + UMSDOS_file_read, /* read */
857: + UMSDOS_file_write, /* write */
858: + NULL, /* readdir - bad */
859: + NULL, /* select - default */
860: + NULL, /* ioctl - default */
861: + generic_file_mmap, /* mmap */
862: + NULL, /* no special open is needed */
863: + NULL, /* release */
864: + file_fsync /* fsync */
865: +};
866: +
867: +struct inode_operations umsdos_file_inode_operations_readpage = {
868: + &umsdos_file_operations_readpage, /* default file operations */
869: + NULL, /* create */
870: + NULL, /* lookup */
871: + NULL, /* link */
872: + NULL, /* unlink */
873: + NULL, /* symlink */
874: + NULL, /* mkdir */
875: + NULL, /* rmdir */
876: + NULL, /* mknod */
877: + NULL, /* rename */
878: + NULL, /* readlink */
879: + NULL, /* follow_link */
880: + fat_readpage, /* readpage */
881: + NULL, /* writepage */
882: + NULL, /* bmap */
883: + UMSDOS_truncate,/* truncate */
884: + NULL, /* permission */
885: + NULL, /* smap */
886: +};
887: +
888: diff -u -r -N linux-2.0.33-cyrix-patched/fs/umsdos/inode.c linux-2.0.33-cyrix-patched-test/fs/umsdos/inode.c
889: --- linux-2.0.33-cyrix-patched/fs/umsdos/inode.c Sat Nov 30 11:21:22 1996
890: +++ linux-2.0.33-cyrix-patched-test/fs/umsdos/inode.c Fri Jan 2 23:55:34 1998
891: @@ -149,11 +149,20 @@
892: if (!umsdos_isinit(inode)){
893: inode->u.umsdos_i.i_emd_dir = 0;
894: if (S_ISREG(inode->i_mode)){
895: + if (MSDOS_SB(inode->i_sb)->cvf_format){
896: + if (MSDOS_SB(inode->i_sb)->cvf_format->flags
897: + &CVF_USE_READPAGE){
898: + inode->i_op = &umsdos_file_inode_operations_readpage;
899: + }else{
900: + inode->i_op = &umsdos_file_inode_operations_no_bmap;
901: + }
902: + } else {
903: if (inode->i_op->bmap != NULL){
904: inode->i_op = &umsdos_file_inode_operations;
905: }else{
906: inode->i_op = &umsdos_file_inode_operations_no_bmap;
907: }
908: + }
909: }else if (S_ISDIR(inode->i_mode)){
910: if (dir != NULL){
911: umsdos_setup_dir_inode(inode);
912: diff -u -r -N linux-2.0.33-cyrix-patched/fs/umsdos/ioctl.c linux-2.0.33-cyrix-patched-test/fs/umsdos/ioctl.c
913: --- linux-2.0.33-cyrix-patched/fs/umsdos/ioctl.c Wed Jul 3 15:39:48 1996
914: +++ linux-2.0.33-cyrix-patched-test/fs/umsdos/ioctl.c Sat Jan 3 13:01:52 1998
915: @@ -60,6 +60,21 @@
916: {
917: int ret = -EPERM;
918: int err;
919: +
920: + /* forward non-umsdos ioctls - this hopefully doesn't cause conflicts */
921: + if(cmd!=UMSDOS_GETVERSION
922: + &&cmd!=UMSDOS_READDIR_DOS
923: + &&cmd!=UMSDOS_READDIR_EMD
924: + &&cmd!=UMSDOS_INIT_EMD
925: + &&cmd!=UMSDOS_CREAT_EMD
926: + &&cmd!=UMSDOS_RENAME_DOS
927: + &&cmd!=UMSDOS_UNLINK_EMD
928: + &&cmd!=UMSDOS_UNLINK_DOS
929: + &&cmd!=UMSDOS_RMDIR_DOS
930: + &&cmd!=UMSDOS_STAT_DOS
931: + &&cmd!=UMSDOS_DOS_SETUP)
932: + return fat_dir_ioctl(dir,filp,cmd,data);
933: +
934: /* #Specification: ioctl / acces
935: Only root (effective id) is allowed to do IOCTL on directory
936: in UMSDOS. EPERM is returned for other user.
937: diff -u -r -N linux-2.0.33-cyrix-patched/include/linux/fat_cvf.h linux-2.0.33-cyrix-patched-test/include/linux/fat_cvf.h
938: --- linux-2.0.33-cyrix-patched/include/linux/fat_cvf.h Thu Jan 1 01:00:00 1970
939: +++ linux-2.0.33-cyrix-patched-test/include/linux/fat_cvf.h Sat Jan 3 12:42:28 1998
940: @@ -0,0 +1,55 @@
941: +#ifndef _FAT_CVF
942: +#define _FAT_CVF
943: +
944: +#define CVF_USE_READPAGE 0x0001
945: +
946: +struct cvf_format
947: +{ int cvf_version;
948: + char* cvf_version_text;
949: + unsigned long flags;
950: + int (*detect_cvf) (struct super_block*sb);
951: + int (*mount_cvf) (struct super_block*sb,char*options);
952: + int (*unmount_cvf) (struct super_block*sb);
953: + struct buffer_head* (*cvf_bread) (struct super_block*sb,int block);
954: + struct buffer_head* (*cvf_getblk) (struct super_block*sb,int block);
955: + void (*cvf_brelse) (struct super_block *sb,struct buffer_head *bh);
956: + void (*cvf_mark_buffer_dirty) (struct super_block *sb,
957: + struct buffer_head *bh,
958: + int dirty_val);
959: + void (*cvf_set_uptodate) (struct super_block *sb,
960: + struct buffer_head *bh,
961: + int val);
962: + int (*cvf_is_uptodate) (struct super_block *sb,struct buffer_head *bh);
963: + void (*cvf_ll_rw_block) (struct super_block *sb,
964: + int opr,
965: + int nbreq,
966: + struct buffer_head *bh[32]);
967: + int (*fat_access) (struct super_block *sb,int nr,int new_value);
968: + void (*cvf_statfs) (struct super_block *sb,struct statfs *buf, int bufsiz);
969: + int (*cvf_bmap) (struct inode *inode,int block);
970: + int (*cvf_smap) (struct inode *inode,int sector);
971: + int (*cvf_file_read) ( struct inode *inode,
972: + struct file *filp,
973: + char *buf,
974: + int count);
975: + int (*cvf_file_write) ( struct inode *inode,
976: + struct file *filp,
977: + const char *buf,
978: + int count);
979: + int (*cvf_mmap) (struct inode*, struct file *, struct vm_area_struct *);
980: + int (*cvf_readpage) (struct inode *, struct page *);
981: + int (*cvf_writepage) (struct inode *, struct page *);
982: + int (*cvf_dir_ioctl) (struct inode * inode, struct file * filp,
983: + unsigned int cmd, unsigned long arg);
984: + void (*zero_out_cluster) (struct inode*, int clusternr);
985: +};
986: +
987: +int register_cvf_format(struct cvf_format*cvf_format);
988: +int unregister_cvf_format(struct cvf_format*cvf_format);
989: +void dec_cvf_format_use_count_by_version(int version);
990: +int detect_cvf(struct super_block*sb,char*force);
991: +
992: +extern struct cvf_format *cvf_formats[];
993: +extern int cvf_format_use_count[];
994: +
995: +#endif
996: diff -u -r -N linux-2.0.33-cyrix-patched/include/linux/msdos_fs.h linux-2.0.33-cyrix-patched-test/include/linux/msdos_fs.h
997: --- linux-2.0.33-cyrix-patched/include/linux/msdos_fs.h Tue Dec 23 22:50:14 1997
998: +++ linux-2.0.33-cyrix-patched-test/include/linux/msdos_fs.h Sat Jan 3 13:03:16 1998
999: @@ -221,12 +221,14 @@
1000: /* file.c */
1001: extern struct inode_operations fat_file_inode_operations;
1002: extern struct inode_operations fat_file_inode_operations_1024;
1003: +extern struct inode_operations fat_file_inode_operations_readpage;
1004: extern int fat_file_read(struct inode *, struct file *, char *, int);
1005: extern int fat_file_write(struct inode *, struct file *, const char *, int);
1006: extern void fat_truncate(struct inode *inode);
1007:
1008: /* mmap.c */
1009: extern int fat_mmap(struct inode *, struct file *, struct vm_area_struct *);
1010: +extern int fat_readpage(struct inode *, struct page *);
1011:
1012:
1013: /* vfat.c */
1014: diff -u -r -N linux-2.0.33-cyrix-patched/include/linux/msdos_fs_sb.h linux-2.0.33-cyrix-patched-test/include/linux/msdos_fs_sb.h
1015: --- linux-2.0.33-cyrix-patched/include/linux/msdos_fs_sb.h Mon Mar 11 10:25:58 1996
1016: +++ linux-2.0.33-cyrix-patched-test/include/linux/msdos_fs_sb.h Sat Jan 3 13:02:03 1998
1017: @@ -1,5 +1,6 @@
1018: #ifndef _MSDOS_FS_SB
1019: #define _MSDOS_FS_SB
1020: +#include<linux/fat_cvf.h>
1021:
1022: /*
1023: * MS-DOS file system in-core superblock data
1024: @@ -34,6 +35,8 @@
1025: int prev_free; /* previously returned free cluster number */
1026: int free_clusters; /* -1 if undefined */
1027: struct fat_mount_options options;
1028: + struct cvf_format* cvf_format;
1029: + void* private_data;
1030: };
1031:
1032: #endif
1033: diff -u -r -N linux-2.0.33-cyrix-patched/include/linux/umsdos_fs.h linux-2.0.33-cyrix-patched-test/include/linux/umsdos_fs.h
1034: --- linux-2.0.33-cyrix-patched/include/linux/umsdos_fs.h Tue Dec 23 22:50:14 1997
1035: +++ linux-2.0.33-cyrix-patched-test/include/linux/umsdos_fs.h Sat Jan 3 13:04:02 1998
1036: @@ -135,6 +135,7 @@
1037: extern struct file_operations umsdos_file_operations;
1038: extern struct inode_operations umsdos_file_inode_operations;
1039: extern struct inode_operations umsdos_file_inode_operations_no_bmap;
1040: +extern struct inode_operations umsdos_file_inode_operations_readpage;
1041: extern struct inode_operations umsdos_symlink_inode_operations;
1042: extern int init_umsdos_fs(void);
1043:
1044: diff -u -r -N linux-2.0.33-cyrix-patched/kernel/ksyms.c linux-2.0.33-cyrix-patched-test/kernel/ksyms.c
1045: --- linux-2.0.33-cyrix-patched/kernel/ksyms.c Sat Nov 22 18:26:32 1997
1046: +++ linux-2.0.33-cyrix-patched-test/kernel/ksyms.c Sat Jan 3 14:03:39 1998
1047: @@ -123,6 +123,9 @@
1048: X(do_mmap),
1049: X(do_munmap),
1050: X(exit_mm),
1051: + X(exit_sighand),
1052: + X(exit_fs),
1053: + X(exit_files),
1054:
1055: /* internal kernel memory management */
1056: X(__get_free_pages),
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.