![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cvf.diff-2.0.34 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.34 CVS log | Up to [GPL Stacker compression] / dmsdos / patches |
1.1 ! root 1: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/Documentation/filesystems/fat_cvf.txt linux-2.0.33-cyrix-patched-fat32-test/Documentation/filesystems/fat_cvf.txt ! 2: --- linux-2.0.33-cyrix-patched-fat32/Documentation/filesystems/fat_cvf.txt Thu Jan 1 01:00:00 1970 ! 3: +++ linux-2.0.33-cyrix-patched-fat32-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-fat32/fs/fat/Makefile linux-2.0.33-cyrix-patched-fat32-test/fs/fat/Makefile ! 216: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/Makefile Wed Feb 7 08:39:27 1996 ! 217: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/Makefile Sun Jan 4 11:59:56 1998 ! 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-fat32/fs/fat/buffer.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/buffer.c ! 228: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/buffer.c Sun Jan 4 11:55:32 1998 ! 229: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/buffer.c Sun Jan 4 12:07:19 1998 ! 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: #if 0 ! 237: # define PRINTK(x) printk x ! 238: @@ -26,6 +27,11 @@ ! 239: /* Note that the blocksize is 512 or 1024, but the first read ! 240: is always of size 1024. Doing readahead may be counterproductive ! 241: or just plain wrong. */ ! 242: + ! 243: + if(MSDOS_SB(sb)->cvf_format) ! 244: + if(MSDOS_SB(sb)->cvf_format->cvf_bread) ! 245: + return MSDOS_SB(sb)->cvf_format->cvf_bread(sb,block); ! 246: + ! 247: if (sb->s_blocksize == 512) { ! 248: ret = bread (sb->s_dev,block,512); ! 249: } else { ! 250: @@ -81,6 +87,11 @@ ! 251: { ! 252: struct buffer_head *ret = NULL; ! 253: PRINTK(("fat_getblk: block=0x%x\n", block)); ! 254: + ! 255: + if(MSDOS_SB(sb)->cvf_format) ! 256: + if(MSDOS_SB(sb)->cvf_format->cvf_getblk) ! 257: + return MSDOS_SB(sb)->cvf_format->cvf_getblk(sb,block); ! 258: + ! 259: if (sb->s_blocksize == 512){ ! 260: ret = getblk (sb->s_dev,block,512); ! 261: }else{ ! 262: @@ -100,6 +111,10 @@ ! 263: struct buffer_head *bh) ! 264: { ! 265: if (bh != NULL){ ! 266: + if(MSDOS_SB(sb)->cvf_format) ! 267: + if(MSDOS_SB(sb)->cvf_format->cvf_brelse) ! 268: + return MSDOS_SB(sb)->cvf_format->cvf_brelse(sb,bh); ! 269: + ! 270: if (sb->s_blocksize == 512){ ! 271: brelse (bh); ! 272: }else{ ! 273: @@ -117,6 +132,12 @@ ! 274: struct buffer_head *bh, ! 275: int dirty_val) ! 276: { ! 277: + if(MSDOS_SB(sb)->cvf_format) ! 278: + if(MSDOS_SB(sb)->cvf_format->cvf_mark_buffer_dirty) ! 279: + { MSDOS_SB(sb)->cvf_format->cvf_mark_buffer_dirty(sb,bh,dirty_val); ! 280: + return; ! 281: + } ! 282: + ! 283: if (sb->s_blocksize != 512){ ! 284: bh = bh->b_next; ! 285: } ! 286: @@ -128,6 +149,12 @@ ! 287: struct buffer_head *bh, ! 288: int val) ! 289: { ! 290: + if(MSDOS_SB(sb)->cvf_format) ! 291: + if(MSDOS_SB(sb)->cvf_format->cvf_set_uptodate) ! 292: + { MSDOS_SB(sb)->cvf_format->cvf_set_uptodate(sb,bh,val); ! 293: + return; ! 294: + } ! 295: + ! 296: if (sb->s_blocksize != 512){ ! 297: bh = bh->b_next; ! 298: } ! 299: @@ -137,6 +164,10 @@ ! 300: struct super_block *sb, ! 301: struct buffer_head *bh) ! 302: { ! 303: + if(MSDOS_SB(sb)->cvf_format) ! 304: + if(MSDOS_SB(sb)->cvf_format->cvf_is_uptodate) ! 305: + return MSDOS_SB(sb)->cvf_format->cvf_is_uptodate(sb,bh); ! 306: + ! 307: if (sb->s_blocksize != 512){ ! 308: bh = bh->b_next; ! 309: } ! 310: @@ -149,6 +180,12 @@ ! 311: int nbreq, ! 312: struct buffer_head *bh[32]) ! 313: { ! 314: + if(MSDOS_SB(sb)->cvf_format) ! 315: + if(MSDOS_SB(sb)->cvf_format->cvf_ll_rw_block) ! 316: + { MSDOS_SB(sb)->cvf_format->cvf_ll_rw_block(sb,opr,nbreq,bh); ! 317: + return; ! 318: + } ! 319: + ! 320: if (sb->s_blocksize == 512){ ! 321: ll_rw_block(opr,nbreq,bh); ! 322: }else{ ! 323: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/cache.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/cache.c ! 324: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/cache.c Sun Jan 4 11:55:32 1998 ! 325: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/cache.c Sun Jan 4 12:08:48 1998 ! 326: @@ -9,6 +9,7 @@ ! 327: #include <linux/errno.h> ! 328: #include <linux/string.h> ! 329: #include <linux/stat.h> ! 330: +#include <linux/fat_cvf.h> ! 331: ! 332: #include "msbuffer.h" ! 333: ! 334: @@ -29,6 +30,10 @@ ! 335: unsigned char *p_first,*p_last; ! 336: int copy,first,last,next,b; ! 337: ! 338: + if(MSDOS_SB(sb)->cvf_format) ! 339: + if(MSDOS_SB(sb)->cvf_format->fat_access) ! 340: + return MSDOS_SB(sb)->cvf_format->fat_access(sb,nr,new_value); ! 341: + ! 342: if ((unsigned) (nr-2) >= MSDOS_SB(sb)->clusters) ! 343: return 0; ! 344: if (MSDOS_SB(sb)->fat_bits == 32) { ! 345: @@ -261,6 +266,10 @@ ! 346: int cluster,offset; ! 347: ! 348: sb = MSDOS_SB(inode->i_sb); ! 349: + if(sb->cvf_format) ! 350: + if(sb->cvf_format->cvf_smap) ! 351: + return sb->cvf_format->cvf_smap(inode,sector); ! 352: + ! 353: if ((sb->fat_bits != 32) && ! 354: (inode->i_ino == MSDOS_ROOT_INO || (S_ISDIR(inode->i_mode) && ! 355: !MSDOS_I(inode)->i_start))) { ! 356: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/cvf.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/cvf.c ! 357: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/cvf.c Thu Jan 1 01:00:00 1970 ! 358: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/cvf.c Tue Nov 17 20:10:41 1998 ! 359: @@ -0,0 +1,147 @@ ! 360: +/* ! 361: + * CVF extensions for fat-based filesystems ! 362: + * ! 363: + * written 1997,1998 by Frank Gockel <[email protected]> ! 364: + * ! 365: + * please do not remove the next line, dmsdos needs it for verifying patches ! 366: + * CVF-FAT-VERSION-ID: 1.1.0 ! 367: + * ! 368: + */ ! 369: + ! 370: +#include<linux/sched.h> ! 371: +#include<linux/fs.h> ! 372: +#include<linux/msdos_fs.h> ! 373: +#include<linux/msdos_fs_sb.h> ! 374: +#include<linux/string.h> ! 375: +#include<linux/fat_cvf.h> ! 376: +#include<linux/config.h> ! 377: +#ifdef CONFIG_KERNELD ! 378: +#include<linux/kerneld.h> ! 379: +#endif ! 380: + ! 381: +#define MAX_CVF_FORMATS 3 ! 382: + ! 383: +struct cvf_format *cvf_formats[MAX_CVF_FORMATS]={NULL,NULL,NULL}; ! 384: +int cvf_format_use_count[MAX_CVF_FORMATS]={0,0,0}; ! 385: + ! 386: +int register_cvf_format(struct cvf_format*cvf_format) ! 387: +{ int i,j; ! 388: + ! 389: + for(i=0;i<MAX_CVF_FORMATS;++i) ! 390: + { if(cvf_formats[i]==NULL) ! 391: + { /* free slot found, now check version */ ! 392: + for(j=0;j<MAX_CVF_FORMATS;++j) ! 393: + { if(cvf_formats[j]) ! 394: + { if(cvf_formats[j]->cvf_version==cvf_format->cvf_version) ! 395: + { printk("register_cvf_format: version %d already registered\n", ! 396: + cvf_format->cvf_version); ! 397: + return -1; ! 398: + } ! 399: + } ! 400: + } ! 401: + cvf_formats[i]=cvf_format; ! 402: + cvf_format_use_count[i]=0; ! 403: + printk("CVF format %s (version id %d) successfully registered.\n", ! 404: + cvf_format->cvf_version_text,cvf_format->cvf_version); ! 405: + return 0; ! 406: + } ! 407: + } ! 408: + ! 409: + printk("register_cvf_format: too many formats\n"); ! 410: + return -1; ! 411: +} ! 412: + ! 413: +int unregister_cvf_format(struct cvf_format*cvf_format) ! 414: +{ int i; ! 415: + ! 416: + for(i=0;i<MAX_CVF_FORMATS;++i) ! 417: + { if(cvf_formats[i]) ! 418: + { if(cvf_formats[i]->cvf_version==cvf_format->cvf_version) ! 419: + { if(cvf_format_use_count[i]) ! 420: + { printk("unregister_cvf_format: format %d in use, cannot remove!\n", ! 421: + cvf_formats[i]->cvf_version); ! 422: + return -1; ! 423: + } ! 424: + ! 425: + printk("CVF format %s (version id %d) successfully unregistered.\n", ! 426: + cvf_formats[i]->cvf_version_text,cvf_formats[i]->cvf_version); ! 427: + cvf_formats[i]=NULL; ! 428: + return 0; ! 429: + } ! 430: + } ! 431: + } ! 432: + ! 433: + printk("unregister_cvf_format: format %d is not registered\n", ! 434: + cvf_format->cvf_version); ! 435: + return -1; ! 436: +} ! 437: + ! 438: +void dec_cvf_format_use_count_by_version(int version) ! 439: +{ int i; ! 440: + ! 441: + for(i=0;i<MAX_CVF_FORMATS;++i) ! 442: + { if(cvf_formats[i]) ! 443: + { if(cvf_formats[i]->cvf_version==version) ! 444: + { --cvf_format_use_count[i]; ! 445: + if(cvf_format_use_count[i]<0) ! 446: + { cvf_format_use_count[i]=0; ! 447: + printk(KERN_EMERG "FAT FS/CVF: This is a bug in cvf_version_use_count\n"); ! 448: + } ! 449: + return; ! 450: + } ! 451: + } ! 452: + } ! 453: + ! 454: + printk("dec_cvf_format_use_count_by_version: version %d not found ???\n", ! 455: + version); ! 456: +} ! 457: + ! 458: +int detect_cvf(struct super_block*sb,char*force) ! 459: +{ int i; ! 460: + int found=0; ! 461: + int found_i=-1; ! 462: + ! 463: + if(force) ! 464: + if(strcmp(force,"autoload")==0) ! 465: + { ! 466: +#ifdef CONFIG_KERNELD ! 467: + request_module("cvf_autoload"); ! 468: + force=NULL; ! 469: +#else ! 470: + printk("cannot autoload CVF modules: kerneld support is not compiled into kernel\n"); ! 471: + return -1; ! 472: +#endif ! 473: + } ! 474: + ! 475: +#ifdef CONFIG_KERNELD ! 476: + if(force) ! 477: + if(*force) ! 478: + request_module(force); ! 479: +#endif ! 480: + ! 481: + if(force) ! 482: + { if(*force) ! 483: + { for(i=0;i<MAX_CVF_FORMATS;++i) ! 484: + { if(cvf_formats[i]) ! 485: + { if(!strcmp(cvf_formats[i]->cvf_version_text,force)) ! 486: + return i; ! 487: + } ! 488: + } ! 489: + printk("CVF format %s unknown (module not loaded?)\n",force); ! 490: + return -1; ! 491: + } ! 492: + } ! 493: + ! 494: + for(i=0;i<MAX_CVF_FORMATS;++i) ! 495: + { if(cvf_formats[i]) ! 496: + { if(cvf_formats[i]->detect_cvf(sb)) ! 497: + { ++found; ! 498: + found_i=i; ! 499: + } ! 500: + } ! 501: + } ! 502: + ! 503: + if(found==1)return found_i; ! 504: + if(found>1)printk("CVF detection ambiguous, please use cvf_format=xxx option\n"); ! 505: + return -1; ! 506: +} ! 507: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/dir.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/dir.c ! 508: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/dir.c Sun Jan 4 11:55:32 1998 ! 509: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/dir.c Sun Jan 4 11:59:56 1998 ! 510: @@ -425,6 +425,7 @@ ! 511: unsigned int cmd, unsigned long arg) ! 512: { ! 513: int err; ! 514: + ! 515: /* ! 516: * We want to provide an interface for Samba to be able ! 517: * to get the short filename for a given long filename. ! 518: @@ -451,6 +452,11 @@ ! 519: vfat_ioctl_fill, NULL, 1, 0, 1); ! 520: } ! 521: default: ! 522: + /* forward ioctl to CVF extension */ ! 523: + if(MSDOS_SB(inode->i_sb)->cvf_format ! 524: + &&MSDOS_SB(inode->i_sb)->cvf_format->cvf_dir_ioctl) ! 525: + return MSDOS_SB(inode->i_sb)->cvf_format-> ! 526: + cvf_dir_ioctl(inode,filp,cmd,arg); ! 527: return -EINVAL; ! 528: } ! 529: ! 530: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/fatfs_syms.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/fatfs_syms.c ! 531: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/fatfs_syms.c Sun Jan 4 11:55:32 1998 ! 532: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/fatfs_syms.c Sun Jan 4 12:11:10 1998 ! 533: @@ -11,6 +11,7 @@ ! 534: ! 535: #include <linux/mm.h> ! 536: #include <linux/msdos_fs.h> ! 537: +#include <linux/fat_cvf.h> ! 538: ! 539: #include "msbuffer.h" ! 540: ! 541: @@ -53,6 +54,13 @@ ! 542: X(fat_uni2esc) X_PUNCT ! 543: X(fat_unlock_creation) X_PUNCT ! 544: X(fat_write_inode) X_PUNCT ! 545: +X(register_cvf_format) X_PUNCT ! 546: +X(unregister_cvf_format) X_PUNCT ! 547: +X(get_cluster) X_PUNCT ! 548: +X(lock_fat) X_PUNCT ! 549: +X(unlock_fat) X_PUNCT ! 550: +X(fat_readpage) X_PUNCT ! 551: +X(fat_dir_ioctl) X_PUNCT ! 552: #if LINUX_VERSION_CODE < ASC_LINUX_VERSION(2,1,0) ! 553: #include <linux/symtab_end.h> ! 554: }; ! 555: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/file.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/file.c ! 556: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/file.c Sun Jan 4 11:55:32 1998 ! 557: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/file.c Sun Jan 4 11:59:56 1998 ! 558: @@ -17,6 +17,7 @@ ! 559: #include <linux/stat.h> ! 560: #include <linux/string.h> ! 561: #include <linux/pagemap.h> ! 562: +#include <linux/fat_cvf.h> ! 563: ! 564: #if LINUX_VERSION_CODE >= ASC_LINUX_VERSION(2,1,0) ! 565: #include <asm/uaccess.h> ! 566: @@ -121,6 +122,40 @@ ! 567: NULL /* smap */ ! 568: }; ! 569: ! 570: +static struct file_operations fat_file_operations_readpage = { ! 571: + NULL, /* lseek - default */ ! 572: + fat_file_read, /* read */ ! 573: + fat_file_write, /* write */ ! 574: + NULL, /* readdir - bad */ ! 575: + NULL, /* select - default */ ! 576: + NULL, /* ioctl - default */ ! 577: + generic_file_mmap, /* mmap */ ! 578: + NULL, /* no special open is needed */ ! 579: + NULL, /* release */ ! 580: + file_fsync /* fsync */ ! 581: +}; ! 582: + ! 583: +struct inode_operations fat_file_inode_operations_readpage = { ! 584: + &fat_file_operations_readpage, /* default file operations */ ! 585: + NULL, /* create */ ! 586: + NULL, /* lookup */ ! 587: + NULL, /* link */ ! 588: + NULL, /* unlink */ ! 589: + NULL, /* symlink */ ! 590: + NULL, /* mkdir */ ! 591: + NULL, /* rmdir */ ! 592: + NULL, /* mknod */ ! 593: + NULL, /* rename */ ! 594: + NULL, /* readlink */ ! 595: + NULL, /* follow_link */ ! 596: + fat_readpage, /* readpage */ ! 597: + NULL, /* writepage */ ! 598: + NULL, /* bmap */ ! 599: + fat_truncate, /* truncate */ ! 600: + NULL, /* permission */ ! 601: + NULL /* smap */ ! 602: +}; ! 603: + ! 604: #define MSDOS_PREFETCH 32 ! 605: struct fat_pre { ! 606: int file_sector;/* Next sector to read in the prefetch table */ ! 607: @@ -183,6 +218,10 @@ ! 608: printk("fat_file_read: inode = NULL\n"); ! 609: return -EINVAL; ! 610: } ! 611: + if(MSDOS_SB(sb)->cvf_format) ! 612: + if(MSDOS_SB(sb)->cvf_format->cvf_file_read) ! 613: + return MSDOS_SB(sb)->cvf_format->cvf_file_read(inode,filp,buf,count); ! 614: + ! 615: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */ ! 616: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) { ! 617: printk("fat_file_read: mode = %07o\n",inode->i_mode); ! 618: @@ -305,6 +344,10 @@ ! 619: printk("fat_file_write: inode = NULL\n"); ! 620: return -EINVAL; ! 621: } ! 622: + if(MSDOS_SB(sb)->cvf_format) ! 623: + if(MSDOS_SB(sb)->cvf_format->cvf_file_write) ! 624: + return MSDOS_SB(sb)->cvf_format->cvf_file_write(inode,filp,buf,count); ! 625: + ! 626: /* S_ISLNK allows for UMSDOS. Should never happen for normal MSDOS */ ! 627: if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) { ! 628: printk("fat_file_write: mode = %07o\n",inode->i_mode); ! 629: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/inode.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/inode.c ! 630: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/inode.c Sun Jan 4 11:55:32 1998 ! 631: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/inode.c Sun Jan 4 12:31:18 1998 ! 632: @@ -22,6 +22,7 @@ ! 633: #include <linux/stat.h> ! 634: #include <linux/locks.h> ! 635: #include <linux/malloc.h> ! 636: +#include <linux/fat_cvf.h> ! 637: ! 638: #include "msbuffer.h" ! 639: ! 640: @@ -88,6 +89,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: if (MSDOS_SB(sb)->fat_bits == 32) { ! 649: fat_clusters_flush(sb); ! 650: } ! 651: @@ -113,7 +118,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,save,*savep; ! 660: char *p; ! 661: @@ -239,6 +245,16 @@ ! 662: ret = 0; ! 663: } ! 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: if (this_char != options) *(this_char-1) = ','; ! 677: if (value) *savep = save; ! 678: @@ -261,6 +277,14 @@ ! 679: struct fat_mount_options opts; ! 680: char buf[50]; ! 681: char *p; ! 682: + int i; ! 683: + char cvf_format[21]; ! 684: + char cvf_options[101]; ! 685: + ! 686: + cvf_format[0]='\0'; ! 687: + cvf_options[0]='\0'; ! 688: + MSDOS_SB(sb)->cvf_format=NULL; ! 689: + MSDOS_SB(sb)->private_data=NULL; ! 690: ! 691: MOD_INC_USE_COUNT; ! 692: if (hardsect_size[MAJOR(sb->s_dev)] != NULL){ ! 693: @@ -270,7 +294,8 @@ ! 694: } ! 695: } ! 696: opts.isvfat = MSDOS_SB(sb)->options.isvfat; ! 697: - if (!parse_options((char *) data, &fat, &blksize, &debug, &opts) ! 698: + if (!parse_options((char *) data, &fat, &blksize, &debug, &opts, ! 699: + cvf_format, cvf_options) ! 700: || (blksize != 512 && blksize != 1024)) { ! 701: sb->s_dev = 0; ! 702: MOD_DEC_USE_COUNT; ! 703: @@ -375,6 +400,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: @@ -392,13 +420,15 @@ ! 714: MSDOS_SB(sb)->root_cluster,MSDOS_SB(sb)->free_clusters); ! 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: @@ -419,6 +449,8 @@ ! 731: MSDOS_SB(sb)->nls_disk = load_nls_default(); ! 732: } else { ! 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: MOD_DEC_USE_COUNT; ! 737: return NULL; ! 738: } ! 739: @@ -433,6 +465,8 @@ ! 740: kfree(opts.iocharset); ! 741: unload_nls(MSDOS_SB(sb)->nls_disk); ! 742: sb->s_dev = 0; ! 743: + if(MSDOS_SB(sb)->private_data)kfree(MSDOS_SB(sb)->private_data); ! 744: + MSDOS_SB(sb)->private_data=NULL; ! 745: MOD_DEC_USE_COUNT; ! 746: return NULL; ! 747: } else { ! 748: @@ -447,9 +481,16 @@ ! 749: unload_nls(MSDOS_SB(sb)->nls_disk); ! 750: if (MSDOS_SB(sb)->nls_io) unload_nls(MSDOS_SB(sb)->nls_io); ! 751: if (opts.iocharset) kfree(opts.iocharset); ! 752: + if(MSDOS_SB(sb)->private_data)kfree(MSDOS_SB(sb)->private_data); ! 753: + MSDOS_SB(sb)->private_data=NULL; ! 754: MOD_DEC_USE_COUNT; ! 755: return NULL; ! 756: } ! 757: + ! 758: + if(i>=0) ! 759: + { MSDOS_SB(sb)->cvf_format=cvf_formats[i]; ! 760: + ++cvf_format_use_count[i]; ! 761: + } ! 762: ! 763: return sb; ! 764: } ! 765: @@ -459,7 +500,13 @@ ! 766: { ! 767: int free,nr; ! 768: struct statfs tmp; ! 769: - ! 770: + ! 771: + if(MSDOS_SB(sb)->cvf_format) ! 772: + if(MSDOS_SB(sb)->cvf_format->cvf_statfs) ! 773: + { MSDOS_SB(sb)->cvf_format->cvf_statfs(sb,buf,bufsiz); ! 774: + return; ! 775: + } ! 776: + ! 777: lock_fat(sb); ! 778: if (MSDOS_SB(sb)->free_clusters != -1) ! 779: free = MSDOS_SB(sb)->free_clusters; ! 780: @@ -488,6 +535,10 @@ ! 781: int cluster,offset; ! 782: ! 783: sb = MSDOS_SB(inode->i_sb); ! 784: + if(sb->cvf_format) ! 785: + if(sb->cvf_format->cvf_bmap) ! 786: + return sb->cvf_format->cvf_bmap(inode,block); ! 787: + ! 788: if ((inode->i_ino == MSDOS_ROOT_INO) && (sb->fat_bits != 32)) { ! 789: return sb->dir_start + block; ! 790: } ! 791: @@ -600,7 +651,12 @@ ! 792: !is_exec(raw_entry->ext))) ! 793: ? S_IRUGO|S_IWUGO : S_IRWXUGO) ! 794: & ~MSDOS_SB(sb)->options.fs_umask) | S_IFREG; ! 795: - inode->i_op = (sb->s_blocksize == 1024) ! 796: + if(MSDOS_SB(sb)->cvf_format) ! 797: + inode->i_op = (MSDOS_SB(sb)->cvf_format->flags&CVF_USE_READPAGE) ! 798: + ? &fat_file_inode_operations_readpage ! 799: + : &fat_file_inode_operations_1024; ! 800: + else ! 801: + inode->i_op = (sb->s_blocksize == 1024) ! 802: ? &fat_file_inode_operations_1024 ! 803: : &fat_file_inode_operations; ! 804: MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start); ! 805: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/misc.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/misc.c ! 806: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/misc.c Sun Jan 4 11:55:32 1998 ! 807: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/misc.c Sun Jan 4 11:59:56 1998 ! 808: @@ -225,6 +225,10 @@ ! 809: #endif ! 810: sector = MSDOS_SB(sb)->data_start+(nr-2)*cluster_size; ! 811: last_sector = sector + cluster_size; ! 812: + if(MSDOS_SB(sb)->cvf_format&& ! 813: + MSDOS_SB(sb)->cvf_format->zero_out_cluster) ! 814: + MSDOS_SB(sb)->cvf_format->zero_out_cluster(inode,nr); ! 815: + else ! 816: for ( ; sector < last_sector; sector++) { ! 817: #ifdef DEBUG ! 818: printk("zeroing sector %d\n",sector); ! 819: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/fat/mmap.c linux-2.0.33-cyrix-patched-fat32-test/fs/fat/mmap.c ! 820: --- linux-2.0.33-cyrix-patched-fat32/fs/fat/mmap.c Sun Jan 4 11:55:32 1998 ! 821: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/fat/mmap.c Sun Jan 4 11:59:56 1998 ! 822: @@ -100,6 +100,9 @@ ! 823: */ ! 824: int fat_mmap(struct inode * inode, struct file * file, struct vm_area_struct * vma) ! 825: { ! 826: + if(MSDOS_SB(inode->i_sb)->cvf_format) ! 827: + if(MSDOS_SB(inode->i_sb)->cvf_format->cvf_mmap) ! 828: + return MSDOS_SB(inode->i_sb)->cvf_format->cvf_mmap(inode,file,vma); ! 829: if (vma->vm_flags & VM_SHARED) /* only PAGE_COW or read-only supported now */ ! 830: return -EINVAL; ! 831: if (vma->vm_offset & (inode->i_sb->s_blocksize - 1)) ! 832: @@ -117,4 +120,12 @@ ! 833: return 0; ! 834: } ! 835: ! 836: +int fat_readpage(struct inode * inode, struct page * page) ! 837: +{ ! 838: + if(MSDOS_SB(inode->i_sb)->cvf_format) ! 839: + if(MSDOS_SB(inode->i_sb)->cvf_format->cvf_readpage) ! 840: + return MSDOS_SB(inode->i_sb)->cvf_format->cvf_readpage(inode,page); ! 841: ! 842: + printk("fat_readpage called with no handler (shouldn't happen)\n"); ! 843: + return -1; ! 844: +} ! 845: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/umsdos/emd.c linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/emd.c ! 846: --- linux-2.0.33-cyrix-patched-fat32/fs/umsdos/emd.c Wed Feb 7 08:39:29 1996 ! 847: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/emd.c Sun Jan 4 11:59:56 1998 ! 848: @@ -32,6 +32,7 @@ ! 849: int ret; ! 850: int old_fs = get_fs(); ! 851: set_fs (KERNEL_DS); ! 852: + MSDOS_I(inode)->i_binary=2; ! 853: ret = fat_file_read(inode,filp,buf,count); ! 854: set_fs (old_fs); ! 855: return ret; ! 856: @@ -48,6 +49,7 @@ ! 857: int ret; ! 858: int old_fs = get_fs(); ! 859: set_fs (KERNEL_DS); ! 860: + MSDOS_I(inode)->i_binary=2; ! 861: ret = fat_file_write(inode,filp,buf,count); ! 862: set_fs (old_fs); ! 863: return ret; ! 864: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/umsdos/file.c linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/file.c ! 865: --- linux-2.0.33-cyrix-patched-fat32/fs/umsdos/file.c Tue Feb 20 09:28:13 1996 ! 866: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/file.c Sun Jan 4 11:59:56 1998 ! 867: @@ -129,3 +129,38 @@ ! 868: NULL, /* smap */ ! 869: }; ! 870: ! 871: +/* For other with larger and unaligned file system with readpage */ ! 872: +struct file_operations umsdos_file_operations_readpage = { ! 873: + NULL, /* lseek - default */ ! 874: + UMSDOS_file_read, /* read */ ! 875: + UMSDOS_file_write, /* write */ ! 876: + NULL, /* readdir - bad */ ! 877: + NULL, /* select - default */ ! 878: + NULL, /* ioctl - default */ ! 879: + generic_file_mmap, /* mmap */ ! 880: + NULL, /* no special open is needed */ ! 881: + NULL, /* release */ ! 882: + file_fsync /* fsync */ ! 883: +}; ! 884: + ! 885: +struct inode_operations umsdos_file_inode_operations_readpage = { ! 886: + &umsdos_file_operations_readpage, /* default file operations */ ! 887: + NULL, /* create */ ! 888: + NULL, /* lookup */ ! 889: + NULL, /* link */ ! 890: + NULL, /* unlink */ ! 891: + NULL, /* symlink */ ! 892: + NULL, /* mkdir */ ! 893: + NULL, /* rmdir */ ! 894: + NULL, /* mknod */ ! 895: + NULL, /* rename */ ! 896: + NULL, /* readlink */ ! 897: + NULL, /* follow_link */ ! 898: + fat_readpage, /* readpage */ ! 899: + NULL, /* writepage */ ! 900: + NULL, /* bmap */ ! 901: + UMSDOS_truncate,/* truncate */ ! 902: + NULL, /* permission */ ! 903: + NULL, /* smap */ ! 904: +}; ! 905: + ! 906: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/umsdos/inode.c linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/inode.c ! 907: --- linux-2.0.33-cyrix-patched-fat32/fs/umsdos/inode.c Sat Nov 30 11:21:22 1996 ! 908: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/inode.c Sun Jan 4 11:59:56 1998 ! 909: @@ -149,11 +149,20 @@ ! 910: if (!umsdos_isinit(inode)){ ! 911: inode->u.umsdos_i.i_emd_dir = 0; ! 912: if (S_ISREG(inode->i_mode)){ ! 913: + if (MSDOS_SB(inode->i_sb)->cvf_format){ ! 914: + if (MSDOS_SB(inode->i_sb)->cvf_format->flags ! 915: + &CVF_USE_READPAGE){ ! 916: + inode->i_op = &umsdos_file_inode_operations_readpage; ! 917: + }else{ ! 918: + inode->i_op = &umsdos_file_inode_operations_no_bmap; ! 919: + } ! 920: + } else { ! 921: if (inode->i_op->bmap != NULL){ ! 922: inode->i_op = &umsdos_file_inode_operations; ! 923: }else{ ! 924: inode->i_op = &umsdos_file_inode_operations_no_bmap; ! 925: } ! 926: + } ! 927: }else if (S_ISDIR(inode->i_mode)){ ! 928: if (dir != NULL){ ! 929: umsdos_setup_dir_inode(inode); ! 930: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/fs/umsdos/ioctl.c linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/ioctl.c ! 931: --- linux-2.0.33-cyrix-patched-fat32/fs/umsdos/ioctl.c Wed Jul 3 15:39:48 1996 ! 932: +++ linux-2.0.33-cyrix-patched-fat32-test/fs/umsdos/ioctl.c Sun Jan 4 11:59:56 1998 ! 933: @@ -60,6 +60,21 @@ ! 934: { ! 935: int ret = -EPERM; ! 936: int err; ! 937: + ! 938: + /* forward non-umsdos ioctls - this hopefully doesn't cause conflicts */ ! 939: + if(cmd!=UMSDOS_GETVERSION ! 940: + &&cmd!=UMSDOS_READDIR_DOS ! 941: + &&cmd!=UMSDOS_READDIR_EMD ! 942: + &&cmd!=UMSDOS_INIT_EMD ! 943: + &&cmd!=UMSDOS_CREAT_EMD ! 944: + &&cmd!=UMSDOS_RENAME_DOS ! 945: + &&cmd!=UMSDOS_UNLINK_EMD ! 946: + &&cmd!=UMSDOS_UNLINK_DOS ! 947: + &&cmd!=UMSDOS_RMDIR_DOS ! 948: + &&cmd!=UMSDOS_STAT_DOS ! 949: + &&cmd!=UMSDOS_DOS_SETUP) ! 950: + return fat_dir_ioctl(dir,filp,cmd,data); ! 951: + ! 952: /* #Specification: ioctl / acces ! 953: Only root (effective id) is allowed to do IOCTL on directory ! 954: in UMSDOS. EPERM is returned for other user. ! 955: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/include/linux/fat_cvf.h linux-2.0.33-cyrix-patched-fat32-test/include/linux/fat_cvf.h ! 956: --- linux-2.0.33-cyrix-patched-fat32/include/linux/fat_cvf.h Thu Jan 1 01:00:00 1970 ! 957: +++ linux-2.0.33-cyrix-patched-fat32-test/include/linux/fat_cvf.h Sun Jan 4 11:59:56 1998 ! 958: @@ -0,0 +1,55 @@ ! 959: +#ifndef _FAT_CVF ! 960: +#define _FAT_CVF ! 961: + ! 962: +#define CVF_USE_READPAGE 0x0001 ! 963: + ! 964: +struct cvf_format ! 965: +{ int cvf_version; ! 966: + char* cvf_version_text; ! 967: + unsigned long flags; ! 968: + int (*detect_cvf) (struct super_block*sb); ! 969: + int (*mount_cvf) (struct super_block*sb,char*options); ! 970: + int (*unmount_cvf) (struct super_block*sb); ! 971: + struct buffer_head* (*cvf_bread) (struct super_block*sb,int block); ! 972: + struct buffer_head* (*cvf_getblk) (struct super_block*sb,int block); ! 973: + void (*cvf_brelse) (struct super_block *sb,struct buffer_head *bh); ! 974: + void (*cvf_mark_buffer_dirty) (struct super_block *sb, ! 975: + struct buffer_head *bh, ! 976: + int dirty_val); ! 977: + void (*cvf_set_uptodate) (struct super_block *sb, ! 978: + struct buffer_head *bh, ! 979: + int val); ! 980: + int (*cvf_is_uptodate) (struct super_block *sb,struct buffer_head *bh); ! 981: + void (*cvf_ll_rw_block) (struct super_block *sb, ! 982: + int opr, ! 983: + int nbreq, ! 984: + struct buffer_head *bh[32]); ! 985: + int (*fat_access) (struct super_block *sb,int nr,int new_value); ! 986: + void (*cvf_statfs) (struct super_block *sb,struct statfs *buf, int bufsiz); ! 987: + int (*cvf_bmap) (struct inode *inode,int block); ! 988: + int (*cvf_smap) (struct inode *inode,int sector); ! 989: + int (*cvf_file_read) ( struct inode *inode, ! 990: + struct file *filp, ! 991: + char *buf, ! 992: + int count); ! 993: + int (*cvf_file_write) ( struct inode *inode, ! 994: + struct file *filp, ! 995: + const char *buf, ! 996: + int count); ! 997: + int (*cvf_mmap) (struct inode*, struct file *, struct vm_area_struct *); ! 998: + int (*cvf_readpage) (struct inode *, struct page *); ! 999: + int (*cvf_writepage) (struct inode *, struct page *); ! 1000: + int (*cvf_dir_ioctl) (struct inode * inode, struct file * filp, ! 1001: + unsigned int cmd, unsigned long arg); ! 1002: + void (*zero_out_cluster) (struct inode*, int clusternr); ! 1003: +}; ! 1004: + ! 1005: +int register_cvf_format(struct cvf_format*cvf_format); ! 1006: +int unregister_cvf_format(struct cvf_format*cvf_format); ! 1007: +void dec_cvf_format_use_count_by_version(int version); ! 1008: +int detect_cvf(struct super_block*sb,char*force); ! 1009: + ! 1010: +extern struct cvf_format *cvf_formats[]; ! 1011: +extern int cvf_format_use_count[]; ! 1012: + ! 1013: +#endif ! 1014: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/include/linux/msdos_fs.h linux-2.0.33-cyrix-patched-fat32-test/include/linux/msdos_fs.h ! 1015: --- linux-2.0.33-cyrix-patched-fat32/include/linux/msdos_fs.h Sun Jan 4 11:55:33 1998 ! 1016: +++ linux-2.0.33-cyrix-patched-fat32-test/include/linux/msdos_fs.h Sun Jan 4 12:40:48 1998 ! 1017: @@ -246,12 +246,14 @@ ! 1018: /* file.c */ ! 1019: extern struct inode_operations fat_file_inode_operations; ! 1020: extern struct inode_operations fat_file_inode_operations_1024; ! 1021: +extern struct inode_operations fat_file_inode_operations_readpage; ! 1022: extern int fat_file_read(struct inode *, struct file *, char *, int); ! 1023: extern int fat_file_write(struct inode *, struct file *, const char *, int); ! 1024: extern void fat_truncate(struct inode *inode); ! 1025: ! 1026: /* mmap.c */ ! 1027: extern int fat_mmap(struct inode *, struct file *, struct vm_area_struct *); ! 1028: +extern int fat_readpage(struct inode *, struct page *); ! 1029: ! 1030: ! 1031: /* vfat.c */ ! 1032: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/include/linux/msdos_fs_sb.h linux-2.0.33-cyrix-patched-fat32-test/include/linux/msdos_fs_sb.h ! 1033: --- linux-2.0.33-cyrix-patched-fat32/include/linux/msdos_fs_sb.h Sun Jan 4 11:55:33 1998 ! 1034: +++ linux-2.0.33-cyrix-patched-fat32-test/include/linux/msdos_fs_sb.h Sun Jan 4 12:02:05 1998 ! 1035: @@ -1,5 +1,6 @@ ! 1036: #ifndef _MSDOS_FS_SB ! 1037: #define _MSDOS_FS_SB ! 1038: +#include<linux/fat_cvf.h> ! 1039: ! 1040: /* ! 1041: * MS-DOS file system in-core superblock data ! 1042: @@ -46,6 +47,8 @@ ! 1043: struct fat_mount_options options; ! 1044: struct nls_table *nls_disk; /* Codepage used on disk */ ! 1045: struct nls_table *nls_io; /* Charset used for input and display */ ! 1046: + struct cvf_format* cvf_format; ! 1047: + void* private_data; ! 1048: }; ! 1049: ! 1050: #endif ! 1051: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/include/linux/umsdos_fs.h linux-2.0.33-cyrix-patched-fat32-test/include/linux/umsdos_fs.h ! 1052: --- linux-2.0.33-cyrix-patched-fat32/include/linux/umsdos_fs.h Tue Dec 23 22:50:14 1997 ! 1053: +++ linux-2.0.33-cyrix-patched-fat32-test/include/linux/umsdos_fs.h Sun Jan 4 12:40:48 1998 ! 1054: @@ -135,6 +135,7 @@ ! 1055: extern struct file_operations umsdos_file_operations; ! 1056: extern struct inode_operations umsdos_file_inode_operations; ! 1057: extern struct inode_operations umsdos_file_inode_operations_no_bmap; ! 1058: +extern struct inode_operations umsdos_file_inode_operations_readpage; ! 1059: extern struct inode_operations umsdos_symlink_inode_operations; ! 1060: extern int init_umsdos_fs(void); ! 1061: ! 1062: diff -u -r -N linux-2.0.33-cyrix-patched-fat32/kernel/ksyms.c linux-2.0.33-cyrix-patched-fat32-test/kernel/ksyms.c ! 1063: --- linux-2.0.33-cyrix-patched-fat32/kernel/ksyms.c Sun Jan 4 11:55:33 1998 ! 1064: +++ linux-2.0.33-cyrix-patched-fat32-test/kernel/ksyms.c Sun Jan 4 11:59:56 1998 ! 1065: @@ -124,6 +124,9 @@ ! 1066: X(do_mmap), ! 1067: X(do_munmap), ! 1068: X(exit_mm), ! 1069: + X(exit_sighand), ! 1070: + X(exit_fs), ! 1071: + X(exit_files), ! 1072: ! 1073: /* internal kernel memory management */ ! 1074: X(__get_free_pages),
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.