home *** CD-ROM | disk | FTP | other *** search
/ Serving the Web / ServingTheWeb1995.disc1of1.iso / linux / slacksrce / kernel-s / v1.1 / umsdos-0.5-d < prev   
Encoding:
Text File  |  1995-03-23  |  27.0 KB  |  1,019 lines
  1. This is a diff relative to linux 1.1.57 or later
  2. This is mostly enhancement of the msdos fs driver to speed things
  3. This is alpha!
  4.  
  5. diff -rc2P linux.1.1.57/fs/Makefile linux/fs/Makefile
  6. *** linux.1.1.57/fs/Makefile    Sat Oct 29 01:14:37 1994
  7. --- linux/fs/Makefile    Tue Oct 25 00:36:40 1994
  8. ***************
  9. *** 21,24 ****
  10. --- 21,26 ----
  11.   ifdef CONFIG_MSDOS_FS
  12.   FS_SUBDIRS := $(FS_SUBDIRS) msdos
  13. + else
  14. + MODULE_FS_SUBDIRS := $(MODULE_FS_SUBDIRS) msdos
  15.   endif
  16.   ifdef CONFIG_PROC_FS
  17. ***************
  18. *** 36,39 ****
  19. --- 38,43 ----
  20.   ifdef CONFIG_UMSDOS_FS
  21.   FS_SUBDIRS := $(FS_SUBDIRS) umsdos
  22. + else
  23. + MODULE_FS_SUBDIRS := $(MODULE_FS_SUBDIRS) umsdos
  24.   endif
  25.   ifdef CONFIG_SYSV_FS
  26. ***************
  27. *** 77,80 ****
  28. --- 81,88 ----
  29.       $(MAKE) CFLAGS="$(CFLAGS) -DMODULE" $(MODULES)
  30.       (cd ../modules;for i in $(MODULES); do ln -sf ../fs/$$i .; done)
  31. +     set -e; for i in $(MODULE_FS_SUBDIRS); do \
  32. +       test ! -d $$i || \
  33. +         { $(MAKE) -C $$i; }; done
  34. + 
  35.   
  36.   else
  37. diff -rc2P linux.1.1.57/fs/msdos/Makefile linux/fs/msdos/Makefile
  38. *** linux.1.1.57/fs/msdos/Makefile    Sun Jul 24 10:39:44 1994
  39. --- linux/fs/msdos/Makefile    Tue Oct 25 22:10:49 1994
  40. ***************
  41. *** 8,11 ****
  42. --- 8,15 ----
  43.   # Note 2! The CFLAGS definitions are now in the main makefile...
  44.   
  45. + ifndef CONFIG_MSDOS_FS
  46. + CFLAGS := $(CFLAGS) -DMODULE
  47. + endif
  48. + 
  49.   .c.s:
  50.       $(CC) $(CFLAGS) -S $<
  51. ***************
  52. *** 15,19 ****
  53.       $(AS) -o $*.o $<
  54.   
  55. ! OBJS=    namei.o inode.o file.o dir.o misc.o fat.o mmap.o
  56.   
  57.   msdos.o: $(OBJS)
  58. --- 19,23 ----
  59.       $(AS) -o $*.o $<
  60.   
  61. ! OBJS=    namei.o inode.o file.o dir.o misc.o fat.o
  62.   
  63.   msdos.o: $(OBJS)
  64. diff -rc2P linux.1.1.57/fs/msdos/dir.c linux/fs/msdos/dir.c
  65. *** linux.1.1.57/fs/msdos/dir.c    Sat Oct 29 01:14:39 1994
  66. --- linux/fs/msdos/dir.c    Tue Oct 25 22:05:19 1994
  67. ***************
  68. *** 19,22 ****
  69. --- 19,24 ----
  70.   
  71.   
  72. + #define PRINTK(X)
  73. + 
  74.   static int msdos_dir_read(struct inode * inode,struct file * filp, char * buf,int count)
  75.   {
  76. ***************
  77. *** 113,117 ****
  78. --- 115,121 ----
  79.                   memcpy_tofs(dirent->d_name,bufname,i+1);
  80.                   put_fs_word(i,&dirent->d_reclen);
  81. +                 PRINTK (("readdir avant brelse\n"));
  82.                   brelse(bh);
  83. +                 PRINTK (("readdir retourne %d\n",i));
  84.                   return ROUND_UP(NAME_OFFSET(dirent) + i + 1);
  85.               }
  86. diff -rc2P linux.1.1.57/fs/msdos/file.c linux/fs/msdos/file.c
  87. *** linux.1.1.57/fs/msdos/file.c    Sun Jul 24 10:39:44 1994
  88. --- linux/fs/msdos/file.c    Sat Oct 29 00:33:33 1994
  89. ***************
  90. *** 11,14 ****
  91. --- 11,15 ----
  92.   
  93.   #include <linux/sched.h>
  94. + #include <linux/locks.h>
  95.   #include <linux/fs.h>
  96.   #include <linux/msdos_fs.h>
  97. ***************
  98. *** 21,24 ****
  99. --- 22,27 ----
  100.   #define MAX(a,b) (((a) > (b)) ? (a) : (b))
  101.   
  102. + #define PRINTK(x)
  103. + 
  104.   static struct file_operations msdos_file_operations = {
  105.       NULL,            /* lseek - default */
  106. ***************
  107. *** 28,32 ****
  108.       NULL,            /* select - default */
  109.       NULL,            /* ioctl - default */
  110. !     msdos_mmap,        /* mmap */
  111.       NULL,            /* no special open is needed */
  112.       NULL,            /* release */
  113. --- 31,35 ----
  114.       NULL,            /* select - default */
  115.       NULL,            /* ioctl - default */
  116. !     generic_mmap,    /* mmap */
  117.       NULL,            /* no special open is needed */
  118.       NULL,            /* release */
  119. ***************
  120. *** 50,78 ****
  121.       msdos_truncate,        /* truncate */
  122.       NULL,            /* permission */
  123. !     msdos_smap        /* smap */
  124. ! };
  125. ! 
  126. ! /* No bmap for MS-DOS FS' that don't align data at kByte boundaries. */
  127. ! 
  128. ! struct inode_operations msdos_file_inode_operations_no_bmap = {
  129. !     &msdos_file_operations,    /* default file operations */
  130. !     NULL,            /* create */
  131. !     NULL,            /* lookup */
  132. !     NULL,            /* link */
  133. !     NULL,            /* unlink */
  134. !     NULL,            /* symlink */
  135. !     NULL,            /* mkdir */
  136. !     NULL,            /* rmdir */
  137. !     NULL,            /* mknod */
  138. !     NULL,            /* rename */
  139. !     NULL,            /* readlink */
  140. !     NULL,            /* follow_link */
  141. !     NULL,            /* bmap */
  142. !     msdos_truncate,        /* truncate */
  143. !     NULL,            /* permission */
  144. !     msdos_smap        /* smap */
  145.   };
  146.   
  147. - 
  148.   /*
  149.       Read a file into user space
  150. --- 53,59 ----
  151.       msdos_truncate,        /* truncate */
  152.       NULL,            /* permission */
  153. !     NULL        /* smap */
  154.   };
  155.   
  156.   /*
  157.       Read a file into user space
  158. ***************
  159. *** 85,94 ****
  160.   {
  161.       char *start;
  162. !     int left,offset,size,sector,cnt;
  163. !     char ch;
  164. !     struct buffer_head *bh;
  165. !     void *data;
  166.   
  167. - /* printk("msdos_file_read\n"); */
  168.       if (!inode) {
  169.           printk("msdos_file_read: inode = NULL\n");
  170. --- 66,81 ----
  171.   {
  172.       char *start;
  173. !     int left,offset,size,cnt;
  174. !     struct {
  175. !         int   to_reada;        /* How many block to read all at once */
  176. !         struct buffer_head *bhreq[64];    /* Buffers not already read */
  177. !         int nbreq;            /* Number of buffers to read */
  178. !         struct buffer_head *bhlist[64];    /* All buffers needed */
  179. !         int nblist;            /* Number of buffers in bhlist */
  180. !         int nolist;
  181. !     }pre;
  182. !     int i;
  183. !         
  184.   
  185.       if (!inode) {
  186.           printk("msdos_file_read: inode = NULL\n");
  187. ***************
  188. *** 101,110 ****
  189.       }
  190.       if (filp->f_pos >= inode->i_size || count <= 0) return 0;
  191.       start = buf;
  192.       while ((left = MIN(inode->i_size-filp->f_pos,count-(buf-start))) > 0){
  193. !         if (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
  194. !             break;
  195.           offset = filp->f_pos & (SECTOR_SIZE-1);
  196. -         if (!(bh = msdos_sread(inode->i_dev,sector,&data))) break;
  197.           filp->f_pos += (size = MIN(SECTOR_SIZE-offset,left));
  198.           if (MSDOS_I(inode)->i_binary) {
  199. --- 88,145 ----
  200.       }
  201.       if (filp->f_pos >= inode->i_size || count <= 0) return 0;
  202. +     /*
  203. +         Tell the buffer cache which block we expect to read in advance
  204. +         Since we are limited with the stack, we preread only 64
  205. +         because we have to keep the result into the local
  206. +         arrays pre.bhlist and pre.bhreq.
  207. +     */
  208. +     {
  209. +         int file_sector = filp->f_pos >> SECTOR_BITS;
  210. +         pre.to_reada = count / SECTOR_SIZE;
  211. +         if (filp->f_reada){
  212. +             int min_read = read_ahead[MAJOR(inode->i_dev)];
  213. +             if (min_read > pre.to_reada) pre.to_reada = min_read;
  214. +         }
  215. +         if (pre.to_reada > 64) pre.to_reada = 64;
  216. +         pre.nbreq = pre.nblist = 0;
  217. +         for (i=0; i<pre.to_reada; i++){
  218. +             int sector;
  219. +             struct buffer_head *bh;
  220. +             if (!(sector = msdos_smap(inode,file_sector++))) break;
  221. +             bh = getblk(inode->i_dev,sector,SECTOR_SIZE);
  222. +             if (bh == NULL)    break;
  223. +             pre.bhlist[pre.nblist++] = bh;
  224. +             if (!bh->b_uptodate){
  225. +                 pre.bhreq[pre.nbreq++] = bh;
  226. +             }
  227. +         }
  228. +         if (pre.nbreq > 0) ll_rw_block (READ,pre.nbreq,pre.bhreq);
  229. +     }
  230.       start = buf;
  231. +     pre.nolist = 0;
  232.       while ((left = MIN(inode->i_size-filp->f_pos,count-(buf-start))) > 0){
  233. !         struct buffer_head *bh;
  234. !         void *data;
  235. !         PRINTK (("file_read pos %d\n",filp->f_pos));
  236. !         if (pre.nolist >= pre.nblist){
  237. !             /* This code is executed when more than 64 sectors */
  238. !             /* are request at once */
  239. !             int sector;
  240. !             if (!(sector = msdos_smap(inode,filp->f_pos >> SECTOR_BITS)))
  241. !                 break;
  242. !             if (!(bh = msdos_sread(inode->i_dev,sector,&data)))
  243. !                 break;
  244. !         }else{
  245. !             bh = pre.bhlist[pre.nolist];
  246. !             pre.bhlist[pre.nolist++] = NULL;
  247. !             data = bh->b_data;
  248. !             wait_on_buffer(bh);
  249. !             if (!bh->b_uptodate){
  250. !                 /* read error  ? */
  251. !                 brelse (bh);
  252. !                 break;
  253. !             }
  254. !         }
  255.           offset = filp->f_pos & (SECTOR_SIZE-1);
  256.           filp->f_pos += (size = MIN(SECTOR_SIZE-offset,left));
  257.           if (MSDOS_I(inode)->i_binary) {
  258. ***************
  259. *** 113,116 ****
  260. --- 148,152 ----
  261.           }
  262.           else for (cnt = size; cnt; cnt--) {
  263. +                 char ch;
  264.                   if ((ch = *((char *) data+offset++)) == '\r')
  265.                       size--;
  266. ***************
  267. *** 120,128 ****
  268.                           filp->f_pos = inode->i_size;
  269.                           brelse(bh);
  270. !                         if (start != buf
  271. !                             && !IS_RDONLY(inode))
  272. !                             inode->i_atime
  273. !                                 = CURRENT_TIME;
  274. !                         return buf-start;
  275.                       }
  276.                   }
  277. --- 156,160 ----
  278.                           filp->f_pos = inode->i_size;
  279.                           brelse(bh);
  280. !                         break;
  281.                       }
  282.                   }
  283. ***************
  284. *** 130,136 ****
  285. --- 162,171 ----
  286.           brelse(bh);
  287.       }
  288. +     for (i=0; i<pre.nblist; i++) brelse (pre.bhlist[i]);
  289.       if (start == buf) return -EIO;
  290.       if (!IS_RDONLY(inode))
  291.           inode->i_atime = CURRENT_TIME;
  292. +     PRINTK (("file_read ret %d\n",(buf-start)));
  293. +     filp->f_reada = 1;    /* Will be reset if a lseek is done */
  294.       return buf-start;
  295.   }
  296. ***************
  297. *** 150,153 ****
  298. --- 185,189 ----
  299.       struct buffer_head *bh;
  300.       void *data;
  301. +     int binary_mode = MSDOS_I(inode)->i_binary;
  302.   
  303.       if (!inode) {
  304. ***************
  305. *** 176,186 ****
  306.           offset = filp->f_pos & (SECTOR_SIZE-1);
  307.           size = MIN(SECTOR_SIZE-offset,MAX(carry,count));
  308. !         if (!(bh = msdos_sread(inode->i_dev,sector,&data))) {
  309.               error = -EIO;
  310.               break;
  311.           }
  312. !         if (MSDOS_I(inode)->i_binary) {
  313. !             memcpy_fromfs(data+(filp->f_pos & (SECTOR_SIZE-1)),
  314. !                 buf,written = size);
  315.               buf += size;
  316.           }
  317. --- 212,229 ----
  318.           offset = filp->f_pos & (SECTOR_SIZE-1);
  319.           size = MIN(SECTOR_SIZE-offset,MAX(carry,count));
  320. !         if (binary_mode && offset == 0 && size == SECTOR_SIZE){
  321. !             /* No need to read the block first since we will */
  322. !             /* completely overwrite it */
  323. !             if (!(bh = getblk(inode->i_dev,sector,SECTOR_SIZE))){
  324. !                 error = -EIO;
  325. !                 break;
  326. !             }
  327. !             data = bh->b_data;
  328. !         }else if (!(bh = msdos_sread(inode->i_dev,sector,&data))) {
  329.               error = -EIO;
  330.               break;
  331.           }
  332. !         if (binary_mode) {
  333. !             memcpy_fromfs(data+offset,buf,written = size);
  334.               buf += size;
  335.           }
  336. ***************
  337. *** 211,214 ****
  338. --- 254,258 ----
  339.               inode->i_dirt = 1;
  340.           }
  341. +         bh->b_uptodate = 1;
  342.           mark_buffer_dirty(bh, 0);
  343.           brelse(bh);
  344. diff -rc2P linux.1.1.57/fs/msdos/inode.c linux/fs/msdos/inode.c
  345. *** linux.1.1.57/fs/msdos/inode.c    Sat Oct 29 01:14:50 1994
  346. --- linux/fs/msdos/inode.c    Thu Oct 27 02:09:11 1994
  347. ***************
  348. *** 11,19 ****
  349. --- 11,27 ----
  350.   #include <linux/string.h>
  351.   #include <linux/ctype.h>
  352. + #include <linux/major.h>
  353. + #include <linux/fs.h>
  354.   #include <linux/stat.h>
  355.   #include <linux/locks.h>
  356.   
  357. + #ifdef MODULE
  358. +     #include <linux/module.h>
  359. +     #include "../../tools/version.h"
  360. + #endif
  361. + 
  362.   #include <asm/segment.h>
  363.   
  364. + extern int *blksize_size[];
  365.   
  366.   void msdos_put_inode(struct inode *inode)
  367. ***************
  368. *** 48,54 ****
  369. --- 56,66 ----
  370.   {
  371.       cache_inval_dev(sb->s_dev);
  372. +     set_blocksize (sb->s_dev,BLOCK_SIZE);
  373.       lock_super(sb);
  374.       sb->s_dev = 0;
  375.       unlock_super(sb);
  376. +     #ifdef MODULE
  377. +         MOD_DEC_USE_COUNT;
  378. +     #endif
  379.       return;
  380.   }
  381. ***************
  382. *** 161,165 ****
  383.       cache_init();
  384.       lock_super(s);
  385. !     bh = bread(s->s_dev, 0, BLOCK_SIZE);
  386.       unlock_super(s);
  387.       if (bh == NULL) {
  388. --- 173,191 ----
  389.       cache_init();
  390.       lock_super(s);
  391. !     if (MAJOR(s->s_dev) == FLOPPY_MAJOR){
  392. !         /* Patch for floppy which lacks a table ??? */
  393. !         static int tbdef[]={
  394. !             1024,1024,1024,1024,1024,
  395. !             1024,1024,1024,1024,1024,
  396. !             1024,1024,1024,1024,1024,
  397. !             1024,1024,1024,1024,1024,
  398. !             1024,1024,1024,1024,1024,
  399. !             1024,1024,1024,1024,1024,
  400. !             1024,1024,1024,1024,1024,
  401. !         };
  402. !         blksize_size[FLOPPY_MAJOR] = tbdef;
  403. !     }
  404. !     set_blocksize (s->s_dev,SECTOR_SIZE);
  405. !     bh = bread(s->s_dev, 0, SECTOR_SIZE);
  406.       unlock_super(s);
  407.       if (bh == NULL) {
  408. ***************
  409. *** 169,175 ****
  410.       }
  411.       b = (struct msdos_boot_sector *) bh->b_data;
  412. !     s->s_blocksize = 1024;    /* we cannot handle anything else yet */
  413. !     s->s_blocksize_bits = 10;    /* we cannot handle anything else yet */
  414. ! 
  415.   /*
  416.    * The DOS3 partition size limit is *not* 32M as many people think.  
  417. --- 195,203 ----
  418.       }
  419.       b = (struct msdos_boot_sector *) bh->b_data;
  420. !     s->s_blocksize = 512;    /* Using this small block size solve the */
  421. !                 /* the misfit with buffer cache and cluster */
  422. !                 /* because cluster (DOS) are often aligned */
  423. !                 /* on odd sector */
  424. !     s->s_blocksize_bits = 9;    /* we cannot handle anything else yet */
  425.   /*
  426.    * The DOS3 partition size limit is *not* 32M as many people think.  
  427. ***************
  428. *** 220,223 ****
  429. --- 248,252 ----
  430.       brelse(bh);
  431.       if (error || debug) {
  432. +         /* The MSDOS_CAN_BMAP is obsolete, but left just to remember */
  433.           printk("[MS-DOS FS Rel. 12,FAT %d,check=%c,conv=%c,"
  434.               "uid=%d,gid=%d,umask=%03o%s]\n",MSDOS_SB(s)->fat_bits,check,
  435. ***************
  436. *** 256,259 ****
  437. --- 285,291 ----
  438.           return NULL;
  439.       }
  440. +     #ifdef MODULE
  441. +         MOD_INC_USE_COUNT;
  442. +     #endif
  443.       return s;
  444.   }
  445. ***************
  446. *** 291,303 ****
  447.   
  448.       sb = MSDOS_SB(inode->i_sb);
  449. -     if ((sb->cluster_size & 1) || (sb->data_start & 1)) return 0;
  450.       if (inode->i_ino == MSDOS_ROOT_INO) {
  451. !         if (sb->dir_start & 1) return 0;
  452. !         return (sb->dir_start >> 1)+block;
  453.       }
  454. !     cluster = (block*2)/sb->cluster_size;
  455. !     offset = (block*2) % sb->cluster_size;
  456.       if (!(cluster = get_cluster(inode,cluster))) return 0;
  457. !     return ((cluster-2)*sb->cluster_size+sb->data_start+offset) >> 1;
  458.   }
  459.   
  460. --- 323,333 ----
  461.   
  462.       sb = MSDOS_SB(inode->i_sb);
  463.       if (inode->i_ino == MSDOS_ROOT_INO) {
  464. !         return sb->dir_start + block;
  465.       }
  466. !     cluster = block/sb->cluster_size;
  467. !     offset = block % sb->cluster_size;
  468.       if (!(cluster = get_cluster(inode,cluster))) return 0;
  469. !     return (cluster-2)*sb->cluster_size+sb->data_start+offset;
  470.   }
  471.   
  472. ***************
  473. *** 333,337 ****
  474.       }
  475.       if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
  476. !         BLOCK_SIZE))) {
  477.           printk("dev = 0x%04X, ino = %ld\n",inode->i_dev,inode->i_ino);
  478.           panic("msdos_read_inode: unable to read i-node block");
  479. --- 363,367 ----
  480.       }
  481.       if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
  482. !         SECTOR_SIZE))) {
  483.           printk("dev = 0x%04X, ino = %ld\n",inode->i_dev,inode->i_ino);
  484.           panic("msdos_read_inode: unable to read i-node block");
  485. ***************
  486. *** 368,374 ****
  487.               ? S_IRUGO|S_IWUGO : S_IRWXUGO) & ~MSDOS_SB(inode->i_sb)->fs_umask) |
  488.               S_IFREG;
  489. !         inode->i_op = MSDOS_CAN_BMAP(MSDOS_SB(inode->i_sb)) ? 
  490. !             &msdos_file_inode_operations :
  491. !             &msdos_file_inode_operations_no_bmap;
  492.           MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
  493.           inode->i_nlink = 1;
  494. --- 398,402 ----
  495.               ? S_IRUGO|S_IWUGO : S_IRWXUGO) & ~MSDOS_SB(inode->i_sb)->fs_umask) |
  496.               S_IFREG;
  497. !         inode->i_op = &msdos_file_inode_operations;    /* Now can always bmap */
  498.           MSDOS_I(inode)->i_start = CF_LE_W(raw_entry->start);
  499.           inode->i_nlink = 1;
  500. ***************
  501. *** 396,400 ****
  502.       if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
  503.       if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
  504. !         BLOCK_SIZE))) {
  505.           printk("dev = 0x%04X, ino = %ld\n",inode->i_dev,inode->i_ino);
  506.           panic("msdos_write_inode: unable to read i-node block");
  507. --- 424,428 ----
  508.       if (inode->i_ino == MSDOS_ROOT_INO || !inode->i_nlink) return;
  509.       if (!(bh = bread(inode->i_dev,inode->i_ino >> MSDOS_DPB_BITS,
  510. !         SECTOR_SIZE))) {
  511.           printk("dev = 0x%04X, ino = %ld\n",inode->i_dev,inode->i_ino);
  512.           panic("msdos_write_inode: unable to read i-node block");
  513. ***************
  514. *** 452,453 ****
  515. --- 480,510 ----
  516.       return 0;
  517.   }
  518. + #ifdef MODULE
  519. + 
  520. + char kernel_version[] = UTS_RELEASE;
  521. + 
  522. + static struct file_system_type msdos_fs_type = {
  523. +     msdos_read_super, "msdos", 1, NULL
  524. + };
  525. + 
  526. + int init_module(void)
  527. + {
  528. +     register_filesystem(&msdos_fs_type);
  529. +     return 0;
  530. + }
  531. + 
  532. + void cleanup_module(void)
  533. + {
  534. +     if (MOD_IN_USE)
  535. +         printk("ne: device busy, remove delayed\n");
  536. +     else
  537. +     {
  538. +         unregister_filesystem(&msdos_fs_type);
  539. +         /* This is not clear why the floppy drivers does not initialise */
  540. +         /* the table, but we left it the way we saw it first */
  541. +         blksize_size[FLOPPY_MAJOR] = NULL;
  542. +     }
  543. + }
  544. + 
  545. + #endif
  546. + 
  547. diff -rc2P linux.1.1.57/fs/msdos/misc.c linux/fs/msdos/misc.c
  548. *** linux.1.1.57/fs/msdos/misc.c    Sat Oct 29 01:13:55 1994
  549. --- linux/fs/msdos/misc.c    Thu Oct 27 23:25:27 1994
  550. ***************
  551. *** 13,16 ****
  552. --- 13,18 ----
  553.   #include <linux/stat.h>
  554.   
  555. + 
  556. + #define PRINTK(x)
  557.   /* Well-known binary file extensions */
  558.   
  559. ***************
  560. *** 110,116 ****
  561.   int msdos_add_cluster(struct inode *inode)
  562.   {
  563. !     int count,nr,limit,last,current,sector;
  564. !     void *data;
  565.       struct buffer_head *bh;
  566.   
  567.       if (inode->i_ino == MSDOS_ROOT_INO) return -ENOSPC;
  568. --- 112,118 ----
  569.   int msdos_add_cluster(struct inode *inode)
  570.   {
  571. !     int count,nr,limit,last,current,sector,last_sector;
  572.       struct buffer_head *bh;
  573. +     int cluster_size = MSDOS_SB(inode->i_sb)->cluster_size;
  574.   
  575.       if (inode->i_ino == MSDOS_ROOT_INO) return -ENOSPC;
  576. ***************
  577. *** 162,190 ****
  578.   if (last) printk("next set to %d\n",fat_access(inode->i_sb,last,-1));
  579.   #endif
  580. !     for (current = 0; current < MSDOS_SB(inode->i_sb)->cluster_size;
  581. !         current++) {
  582. !         sector = MSDOS_SB(inode->i_sb)->data_start+(nr-2)*
  583. !             MSDOS_SB(inode->i_sb)->cluster_size+current;
  584. ! #ifdef DEBUG
  585. ! printk("zeroing sector %d\n",sector);
  586. ! #endif
  587. !         if (current < MSDOS_SB(inode->i_sb)->cluster_size-1 &&
  588. !             !(sector & 1)) {
  589. !             if (!(bh = getblk(inode->i_dev,sector >> 1,
  590. !                 BLOCK_SIZE)))
  591. !                 printk("getblk failed\n");
  592. !             else {
  593. !                 memset(bh->b_data,0,BLOCK_SIZE);
  594. !                 bh->b_uptodate = 1;
  595. !             }
  596. !             current++;
  597. !         }
  598.           else {
  599. !             if (!(bh = msdos_sread(inode->i_dev,sector,
  600. !                 &data)))
  601. !                 printk("msdos_sread failed\n");
  602. !             else memset(data,0,SECTOR_SIZE);
  603. !         }
  604. !         if (bh) {
  605.               mark_buffer_dirty(bh, 1);
  606.               brelse(bh);
  607. --- 164,178 ----
  608.   if (last) printk("next set to %d\n",fat_access(inode->i_sb,last,-1));
  609.   #endif
  610. !     sector = MSDOS_SB(inode->i_sb)->data_start+(nr-2)*cluster_size;
  611. !     last_sector = sector + cluster_size;
  612. !     for ( ; sector < last_sector; sector++) {
  613. !         #ifdef DEBUG
  614. !             printk("zeroing sector %d\n",sector);
  615. !         #endif
  616. !         if (!(bh = getblk(inode->i_dev,sector,SECTOR_SIZE)))
  617. !             printk("getblk failed\n");
  618.           else {
  619. !             memset(bh->b_data,0,SECTOR_SIZE);
  620. !             bh->b_uptodate = 1;
  621.               mark_buffer_dirty(bh, 1);
  622.               brelse(bh);
  623. ***************
  624. *** 191,195 ****
  625.           }
  626.       }
  627. !     inode->i_blocks += MSDOS_SB(inode->i_sb)->cluster_size;
  628.       if (S_ISDIR(inode->i_mode)) {
  629.           if (inode->i_size & (SECTOR_SIZE-1)) {
  630. --- 179,183 ----
  631.           }
  632.       }
  633. !     inode->i_blocks += cluster_size;
  634.       if (S_ISDIR(inode->i_mode)) {
  635.           if (inode->i_size & (SECTOR_SIZE-1)) {
  636. ***************
  637. *** 198,203 ****
  638.                   ~(SECTOR_SIZE-1);
  639.           }
  640. !         inode->i_size += SECTOR_SIZE*MSDOS_SB(inode->i_sb)->
  641. !             cluster_size;
  642.   #ifdef DEBUG
  643.   printk("size is %d now (%x)\n",inode->i_size,inode);
  644. --- 186,190 ----
  645.                   ~(SECTOR_SIZE-1);
  646.           }
  647. !         inode->i_size += SECTOR_SIZE*cluster_size;
  648.   #ifdef DEBUG
  649.   printk("size is %d now (%x)\n",inode->i_size,inode);
  650. ***************
  651. *** 274,279 ****
  652. --- 261,268 ----
  653.       while (1) {
  654.           offset = *pos;
  655. +         PRINTK (("get_entry offset %d\n",offset));
  656.           if ((sector = msdos_smap(dir,offset >> SECTOR_BITS)) == -1)
  657.               return -1;
  658. +         PRINTK (("get_entry sector %d %p\n",sector,*bh));
  659.           if (!sector)
  660.               return -1; /* beyond EOF */
  661. ***************
  662. *** 281,284 ****
  663. --- 270,274 ----
  664.           if (*bh)
  665.               brelse(*bh);
  666. +         PRINTK (("get_entry sector apres brelse\n"));
  667.           if (!(*bh = msdos_sread(dir->i_dev,sector,&data))) {
  668.               printk("Directory sread (sector %d) failed\n",sector);
  669. ***************
  670. *** 285,288 ****
  671. --- 275,279 ----
  672.               continue;
  673.           }
  674. +         PRINTK (("get_entry apres sread\n"));
  675.           *de = (struct msdos_dir_entry *) (data+(offset &
  676.               (SECTOR_SIZE-1)));
  677. Only in linux.1.1.57/fs/msdos: mmap.c
  678. diff -rc2P linux.1.1.57/fs/msdos/namei.c linux/fs/msdos/namei.c
  679. *** linux.1.1.57/fs/msdos/namei.c    Sat Oct 29 01:13:55 1994
  680. --- linux/fs/msdos/namei.c    Tue Oct 25 22:12:48 1994
  681. ***************
  682. *** 14,17 ****
  683. --- 14,19 ----
  684.   #include <linux/stat.h>
  685.   
  686. + #define PRINTK(x)
  687. + 
  688.   /* MS-DOS "device special files" */
  689.   
  690. ***************
  691. *** 110,113 ****
  692. --- 112,117 ----
  693.       struct buffer_head *bh;
  694.       struct inode *next;
  695. +     
  696. +     PRINTK (("msdos_lookup\n"));
  697.   
  698.       *result = NULL;
  699. ***************
  700. *** 117,120 ****
  701. --- 121,125 ----
  702.           return -ENOENT;
  703.       }
  704. +     PRINTK (("msdos_lookup 2\n"));
  705.       if (len == 1 && name[0] == '.') {
  706.           *result = dir;
  707. ***************
  708. *** 128,131 ****
  709. --- 133,137 ----
  710.           return 0;
  711.       }
  712. +     PRINTK (("msdos_lookup 3\n"));
  713.       if ((res = msdos_find(dir,name,len,&bh,&de,&ino)) < 0) {
  714.           iput(dir);
  715. ***************
  716. *** 132,136 ****
  717. --- 138,144 ----
  718.           return res;
  719.       }
  720. +     PRINTK (("msdos_lookup 4\n"));
  721.       if (bh) brelse(bh);
  722. +     PRINTK (("msdos_lookup 4.5\n"));
  723.   /* printk("lookup: ino=%d\n",ino); */
  724.       if (!(*result = iget(dir->i_sb,ino))) {
  725. ***************
  726. *** 138,141 ****
  727. --- 146,150 ----
  728.           return -EACCES;
  729.       }
  730. +     PRINTK (("msdos_lookup 5\n"));
  731.       if (MSDOS_I(*result)->i_busy) { /* mkdir in progress */
  732.           iput(*result);
  733. ***************
  734. *** 143,146 ****
  735. --- 152,156 ----
  736.           return -ENOENT;
  737.       }
  738. +     PRINTK (("msdos_lookup 6\n"));
  739.       while (MSDOS_I(*result)->i_old) {
  740.           next = MSDOS_I(*result)->i_old;
  741. ***************
  742. *** 152,156 ****
  743. --- 162,168 ----
  744.           }
  745.       }
  746. +     PRINTK (("msdos_lookup 7\n"));
  747.       iput(dir);
  748. +     PRINTK (("msdos_lookup 8\n"));
  749.       return 0;
  750.   }
  751. diff -rc2P linux.1.1.57/fs/umsdos/Makefile linux/fs/umsdos/Makefile
  752. *** linux.1.1.57/fs/umsdos/Makefile    Sun Jul 24 10:39:44 1994
  753. --- linux/fs/umsdos/Makefile    Mon Oct 24 23:16:36 1994
  754. ***************
  755. *** 8,11 ****
  756. --- 8,15 ----
  757.   # Note 2! The CFLAGS definitions are now in the main makefile...
  758.   
  759. + ifndef CONFIG_UMSDOS_FS
  760. + CFLAGS := $(CFLAGS) -DMODULE
  761. + endif
  762. + 
  763.   .c.s:
  764.       $(CC) $(CFLAGS) -S $<
  765. diff -rc2P linux.1.1.57/fs/umsdos/dir.c linux/fs/umsdos/dir.c
  766. *** linux.1.1.57/fs/umsdos/dir.c    Wed Aug 10 12:26:28 1994
  767. --- linux/fs/umsdos/dir.c    Fri Oct 28 23:49:10 1994
  768. ***************
  769. *** 351,354 ****
  770. --- 351,355 ----
  771.               /* This is a DOS directory */
  772.               struct file filp;
  773. +             filp.f_reada = 1;
  774.               filp.f_pos = 0;
  775.               while (1){
  776. ***************
  777. *** 371,374 ****
  778. --- 372,376 ----
  779.               /* skip . and .. see umsdos_readdir_x() */
  780.               struct file filp;
  781. +             filp.f_reada = 1;
  782.               filp.f_pos = UMSDOS_SPECIAL_DIRFPOS;
  783.               while (1){
  784. ***************
  785. *** 624,627 ****
  786. --- 626,630 ----
  787.       }else{
  788.           struct file filp;
  789. +         filp.f_reada = 1;
  790.           filp.f_pos = 0;
  791.           PRINTK (("hlink2inode "));
  792. diff -rc2P linux.1.1.57/fs/umsdos/emd.c linux/fs/umsdos/emd.c
  793. *** linux.1.1.57/fs/umsdos/emd.c    Wed Aug 10 12:26:28 1994
  794. --- linux/fs/umsdos/emd.c    Fri Oct 28 23:52:35 1994
  795. ***************
  796. *** 198,201 ****
  797. --- 198,202 ----
  798.       }
  799.       filp.f_pos = info->f_pos;
  800. +     filp.f_reada = 0;
  801.       ret = umsdos_emd_dir_write(emd_dir,&filp,(char*)entry,info->recsize);
  802.       if (ret != 0){
  803. ***************
  804. *** 297,300 ****
  805. --- 298,302 ----
  806.           buf.size = 0;
  807.           buf.filp.f_pos = 0;
  808. +         buf.filp.f_reada = 1;
  809.           empty.found = 0;
  810.           empty.posok = emd_dir->i_size;
  811. ***************
  812. *** 455,458 ****
  813. --- 457,461 ----
  814.           /* Find an empty slot */
  815.           filp.f_pos = 0;
  816. +         filp.f_reada = 1;
  817.           filp.f_flags = O_RDONLY;
  818.           ret = 1;
  819. diff -rc2P linux.1.1.57/fs/umsdos/file.c linux/fs/umsdos/file.c
  820. *** linux.1.1.57/fs/umsdos/file.c    Sat Oct 29 01:15:54 1994
  821. --- linux/fs/umsdos/file.c    Tue Oct 25 22:15:27 1994
  822. ***************
  823. *** 76,80 ****
  824.       NULL,                /* select - default */
  825.       NULL,                /* ioctl - default */
  826. !     msdos_mmap,            /* mmap */
  827.       NULL,                /* no special open is needed */
  828.       NULL,                /* release */
  829. --- 76,80 ----
  830.       NULL,                /* select - default */
  831.       NULL,                /* ioctl - default */
  832. !     generic_mmap,            /* mmap */
  833.       NULL,                /* no special open is needed */
  834.       NULL,                /* release */
  835. diff -rc2P linux.1.1.57/fs/umsdos/inode.c linux/fs/umsdos/inode.c
  836. *** linux.1.1.57/fs/umsdos/inode.c    Sat Oct 29 01:14:51 1994
  837. --- linux/fs/umsdos/inode.c    Thu Oct 27 02:10:43 1994
  838. ***************
  839. *** 19,22 ****
  840. --- 19,27 ----
  841.   #include <linux/umsdos_fs.h>
  842.   
  843. + #ifdef MODULE
  844. +     #include <linux/module.h>
  845. +     #include "../../tools/version.h"
  846. + #endif
  847. + 
  848.   struct inode *pseudo_root=NULL;        /* Useful to simulate the pseudo DOS */
  849.                                       /* directory. See UMSDOS_readdir_x() */
  850. ***************
  851. *** 49,52 ****
  852. --- 54,60 ----
  853.   {
  854.       msdos_put_super(sb);
  855. +     #ifdef MODULE
  856. +         MOD_DEC_USE_COUNT;
  857. +     #endif
  858.   }
  859.   
  860. ***************
  861. *** 396,400 ****
  862.       */
  863.       struct super_block *sb = msdos_read_super(s,data,silent);
  864. !     printk ("UMSDOS Alpha 0.4 (compatibility level %d.%d)\n"
  865.           ,UMSDOS_VERSION,UMSDOS_RELEASE);
  866.       if (sb != NULL){
  867. --- 404,408 ----
  868.       */
  869.       struct super_block *sb = msdos_read_super(s,data,silent);
  870. !     printk ("UMSDOS Alpha 0.5 (compatibility level %d.%d, fast msdos)\n"
  871.           ,UMSDOS_VERSION,UMSDOS_RELEASE);
  872.       if (sb != NULL){
  873. ***************
  874. *** 464,467 ****
  875. --- 472,478 ----
  876.               iput (pseudo);
  877.           }
  878. +         #ifdef MODULE
  879. +             MOD_INC_USE_COUNT;
  880. +         #endif
  881.       }
  882.       return sb;
  883. ***************
  884. *** 468,470 ****
  885. --- 479,507 ----
  886.   }
  887.   
  888. + 
  889. + #ifdef MODULE
  890. + 
  891. + char kernel_version[] = UTS_RELEASE;
  892. + 
  893. + static struct file_system_type umsdos_fs_type = {
  894. +     UMSDOS_read_super, "umsdos", 1, NULL
  895. + };
  896. + 
  897. + int init_module(void)
  898. + {
  899. +     register_filesystem(&umsdos_fs_type);
  900. +     return 0;
  901. + }
  902. + 
  903. + void cleanup_module(void)
  904. + {
  905. +     if (MOD_IN_USE)
  906. +         printk("Umsdos: file system in use, remove delayed\n");
  907. +     else
  908. +     {
  909. +         unregister_filesystem(&umsdos_fs_type);
  910. +     }
  911. + }
  912. + 
  913. + #endif
  914.   
  915. diff -rc2P linux.1.1.57/fs/umsdos/symlink.c linux/fs/umsdos/symlink.c
  916. *** linux.1.1.57/fs/umsdos/symlink.c    Wed Aug 10 12:26:28 1994
  917. --- linux/fs/umsdos/symlink.c    Fri Oct 28 23:53:46 1994
  918. ***************
  919. *** 35,38 ****
  920. --- 35,39 ----
  921.       struct file filp;
  922.       filp.f_pos = 0;
  923. +     filp.f_reada = 0;
  924.       if (ret > bufsiz) ret = bufsiz;
  925.       if ((*msdos_read) (inode, &filp, buffer,ret) != ret){
  926. diff -rc2P linux.1.1.57/include/linux/msdos_fs.h linux/include/linux/msdos_fs.h
  927. *** linux.1.1.57/include/linux/msdos_fs.h    Sat Oct 29 01:14:52 1994
  928. --- linux/include/linux/msdos_fs.h    Mon Oct 24 23:16:36 1994
  929. ***************
  930. *** 12,17 ****
  931.   #define SECTOR_SIZE     512 /* sector size (bytes) */
  932.   #define SECTOR_BITS    9 /* log2(SECTOR_SIZE) */
  933. ! #define MSDOS_DPB    (MSDOS_DPS*2) /* dir entries per block */
  934. ! #define MSDOS_DPB_BITS    5 /* log2(MSDOS_DPB) */
  935.   #define MSDOS_DPS    (SECTOR_SIZE/sizeof(struct msdos_dir_entry))
  936.   #define MSDOS_DPS_BITS    4 /* log2(MSDOS_DPS) */
  937. --- 12,17 ----
  938.   #define SECTOR_SIZE     512 /* sector size (bytes) */
  939.   #define SECTOR_BITS    9 /* log2(SECTOR_SIZE) */
  940. ! #define MSDOS_DPB    (MSDOS_DPS) /* dir entries per block */
  941. ! #define MSDOS_DPB_BITS    4 /* log2(MSDOS_DPB) */
  942.   #define MSDOS_DPS    (SECTOR_SIZE/sizeof(struct msdos_dir_entry))
  943.   #define MSDOS_DPS_BITS    4 /* log2(MSDOS_DPS) */
  944. ***************
  945. *** 113,121 ****
  946.   static inline struct buffer_head *msdos_sread(int dev,int sector,void **start)
  947.   {
  948. !      struct buffer_head *bh;
  949. ! 
  950. !     if (!(bh = bread(dev,sector >> 1, 1024)))
  951. !         return NULL;
  952. !         *start = bh->b_data+((sector & 1) << SECTOR_BITS);
  953.       return bh;
  954.   }
  955. --- 113,120 ----
  956.   static inline struct buffer_head *msdos_sread(int dev,int sector,void **start)
  957.   {
  958. !      struct buffer_head *bh = bread(dev,sector, 512);
  959. !     if (bh != NULL){
  960. !         *start = bh->b_data;    /* From the time of 1024 bytes block */
  961. !     }
  962.       return bh;
  963.   }
  964. diff -rc2P linux.1.1.57/kernel/ksyms.c linux/kernel/ksyms.c
  965. *** linux.1.1.57/kernel/ksyms.c    Sat Oct 29 01:14:47 1994
  966. --- linux/kernel/ksyms.c    Sat Oct 29 00:43:56 1994
  967. ***************
  968. *** 28,31 ****
  969. --- 28,32 ----
  970.   #include <linux/tty.h>
  971.   #include <linux/serial.h>
  972. + #include <linux/locks.h>
  973.   #ifdef CONFIG_INET
  974.   #include <linux/net.h>
  975. ***************
  976. *** 45,48 ****
  977. --- 46,51 ----
  978.   #endif
  979.   
  980. + extern int sys_tz;
  981. + extern int ___strtok;
  982.   extern int request_dma(unsigned int dmanr, char * deviceID);
  983.   extern void free_dma(unsigned int dmanr);
  984. ***************
  985. *** 200,204 ****
  986.       X(dev_base),
  987.   #endif
  988. ! 
  989.       /********************************************************
  990.        * Do not add anything below this line,
  991. --- 203,229 ----
  992.       X(dev_base),
  993.   #endif
  994. !     /* Added to make file system as module */
  995. !     X(set_writetime),
  996. !     X(getblk),
  997. !     X(inode_setattr),
  998. !     X(sys_tz),
  999. !     X(inode_change_ok),
  1000. !     X(__wait_on_super),
  1001. !     X(file_fsync),
  1002. !     X(simple_strtoul),
  1003. !     X(generic_mmap),
  1004. !     X(set_blocksize),
  1005. !     X(clear_inode),
  1006. !     X(refile_buffer),
  1007. !     X(___strtok),
  1008. !     X(brelse),
  1009. !     X(bread),
  1010. !     X(init_fifo),
  1011. !     X(super_blocks),
  1012. !     X(chrdev_inode_operations),
  1013. !     X(blkdev_inode_operations),
  1014. !     X(ll_rw_block),
  1015. !     X(__wait_on_buffer),
  1016. !     X(read_ahead),
  1017.       /********************************************************
  1018.        * Do not add anything below this line,
  1019.