![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dstacker_alloc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GPL Stacker compression] / dmsdos / src|
Return to dstacker_alloc.c CVS log | Up to [GPL Stacker compression] / dmsdos / src |
1.1 root 1: /*
2: dstacker_alloc.c
3:
4: DMSDOS CVF-FAT module: stacker allocation routines.
5:
6: ******************************************************************************
7: DMSDOS (compressed MSDOS filesystem support) for Linux
8: written 1995-1998 by Frank Gockel and Pavel Pisa
9:
10: (C) Copyright 1995-1998 by Frank Gockel
11: (C) Copyright 1996-1998 by Pavel Pisa
12:
13: Some code of dmsdos has been copied from the msdos filesystem
14: so there are the following additional copyrights:
15:
16: (C) Copyright 1992,1993 by Werner Almesberger (msdos filesystem)
17: (C) Copyright 1994,1995 by Jacques Gelinas (mmap code)
18: (C) Copyright 1992-1995 by Linus Torvalds
19:
20: DMSDOS was inspired by the THS filesystem (a simple doublespace
21: DS-0-2 compressed read-only filesystem) written 1994 by Thomas Scheuermann.
22:
23: The DMSDOS code is distributed under the Gnu General Public Licence.
24: See file COPYING for details.
25: ******************************************************************************
26:
27: */
28:
29: #ifdef __KERNEL__
30: #include <linux/sched.h>
31: #include <linux/ctype.h>
32: #include <linux/major.h>
33: #include <linux/blkdev.h>
34: #include <linux/fs.h>
35: #include <linux/stat.h>
36: #include <linux/locks.h>
37: #include <asm/segment.h>
38: #include <linux/mm.h>
39: #include <linux/malloc.h>
40: #include <linux/string.h>
41: #include <linux/msdos_fs.h>
42: #include <linux/errno.h>
43: #include <linux/kernel.h>
44: #include <linux/shm.h>
45: #include <linux/mman.h>
46: #include <asm/system.h>
47: #endif
48:
49: #include "dmsdos.h"
50:
51: #ifdef __DMSDOS_LIB__
52: /* some interface hacks */
53: #include"lib_interface.h"
54: #include<malloc.h>
55: #include<errno.h>
56: #endif
57:
58:
59: #ifdef DMSDOS_CONFIG_STAC
60:
61: /* initializes Stac_cwalk structure, which can be used for sequential
62: access to all sectors of cluster and when needed informs about
63: all data areas in every sector. flg parameter speedups initialization
64: when some informations are not necessarry
65: flg = 0 .. only sector numbers
66: flg = 1 .. sector numbers and data without ending suballocation
67: flg = 2 .. sector numbers and exact data areas
68: flg = 3 .. same as 2 but more checking
69: */
70: int stac_cwalk_init(Stac_cwalk *cw,struct super_block*sb,
71: int clusternr,int flg)
72: {
73: __u8 *pp;
74: unsigned u,v;
75: int i;
76: int last_sect;
77: Mdfat_entry mde;
78: struct buffer_head *bh;
79: Dblsb*dblsb=MSDOS_SB(sb)->private_data;
80: cw->finfo=NULL;
81: cw->fbh=NULL;
82: cw->sect=0;
83: cw->sb=sb;
84: cw->clusternr=clusternr;
85: /* -------------------------------------------- */
86: dbl_mdfat_value(sb,clusternr,NULL,&mde);
87: cw->start_sect=mde.sector_minus_1+1;
88: cw->sect_cnt=cw->start_len=mde.size_lo_minus_1+1;
89: cw->flags=mde.flags;
90: if(!cw->start_sect) {cw->fcnt=0;return 0;};
91: /* -------------------------------------------- */
92: cw->fcnt=1;
93: cw->flen=cw->sect_cnt=cw->start_len;
94: cw->bytes_in_clust=cw->sect_cnt*SECTOR_SIZE;
95: cw->offset=0;
96: cw->bytes=SECTOR_SIZE;
97: cw->bytes_in_last=0;
98: last_sect=cw->start_sect+cw->sect_cnt-1;
99: /* -------------------------------------------- */
100: u=(cw->flags&0xe0)>>5;
101: if(cw->start_len==dblsb->s_sectperclust) u|=0x8;
102: switch(u)
103: { case 0x0: /* ffff=000x, len<ClustSize, compressed, regular file/dir */
104: case 0x2: /* ffff=010x, deleted 0 */
105: cw->compressed=1;
106: break;
107:
108: case 0x1: /* ffff=001x, not compressed but not full size, regular file/dir */
109: case 0x3: /* ffff=011x, deleted 1 */
110: case 0x8: /* ffff=000x, len=ClustSize, not compressed, regular file/dir */
111: case 0xa: /* ffff=010x, deleted 8 */
112: case 0xc: /* ffff=100x, len=ClustSize, directory, never compressed */
113: case 0xe: /* ffff=110x, deleted c */
114: cw->compressed=0;
115: break;
116:
117: case 0x4: /* ffff=100x, len<ClustSize, fragmented, regular file/dir */
118: case 0x6: /* ffff=110x, deleted 4 */
119: bh=raw_bread(sb,cw->start_sect);
120: if(bh==NULL)return -1;
121: pp=bh->b_data;
122: if(pp[0]!=0xed) /* check fragment signature */
123: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: fragment signature not found cluster=%d\n",
124: clusternr);
125: raw_brelse(sb,bh);
126: return -1;
127: }
128: cw->fcnt=pp[1]+1; /* number of pieces */
129: if((cw->fcnt>dblsb->s_sectperclust)||(cw->fcnt*4>SECTOR_SIZE))
130: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: too much fragmented cluster=%d!\n",
131: clusternr);
132: raw_brelse(sb,bh);
133: return -1;
134: };
135: cw->compressed=!(pp[2]&0x80);
136: v=cw->sect_cnt;
137: cw->sect_cnt+=(pp[2]&0x3F)+1;
138: for(i=1;i<cw->fcnt;++i)
139: { pp+=4;
140: u=(pp[2]&0xf)+((pp[3]>>2)&0x30);
141: v+=u+1;
142: };
143: last_sect=pp[0]+(pp[1]<<8)+((pp[3]&0x3f)<<16)+u; /* for suballocation tests */
144: if(v!=cw->sect_cnt)
145: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: sector count mismash fragmented cluster=%d!\n",
146: clusternr);
147: raw_brelse(sb,bh);
148: return -1;
149: }
150: cw->fbh=bh;
151: cw->finfo=bh->b_data+4;
152: cw->offset=4*cw->fcnt;
153: cw->bytes=SECTOR_SIZE-cw->offset;
154: cw->bytes_in_clust=(cw->sect_cnt-1)*SECTOR_SIZE+cw->bytes;
155: break;
156:
157: case 0x5: /* ffff=101x, len<ClustSize, suballocated, regular file/dir(?) */
158: case 0x7: /* ffff=111x, deleted 5 */
159: case 0xd: /* ffff=101x, len=ClustSize, suballocated, regular file/dir(?) */
160: case 0xf: /* ffff=111x, deleted d */
161: if(flg==0) {cw->bytes_in_clust=0;cw->bytes=0;return 1;};
162: bh=raw_bread(sb,cw->start_sect);
163: if(bh==NULL)return -1;
164: pp=&(bh->b_data[SECTOR_SIZE-2]);
165: if(CHS(pp)!=0x1234)
166: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: suballocation signature not found cluster=%d\n",
167: clusternr);
168: raw_brelse(sb,bh);
169: return -1;
170: }
171: if(cw->start_len==1)
172: { /* short suballocation */
173: pp = &(bh->b_data[SECTOR_SIZE-6]);
174: cw->offset= CHS(pp) & (SECTOR_SIZE - 1); /* begin of area */
175: cw->compressed= !(CHS(pp) & 0x8000);
176: if(CHS(pp)&0x4000)
177: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: suballocation not present, cluster %d\n",
178: clusternr);
179: raw_brelse(sb,bh); return -1;
180: };
181: pp = &(bh->b_data[SECTOR_SIZE-8]);
182: cw->bytes=CHS(pp) & (SECTOR_SIZE - 1); /* end of area */
183: /* some more paranoic checking of allocated space */
184: if (cw->bytes&&(cw->bytes<=SECTOR_SIZE-8)&&(cw->bytes>cw->offset))
185: cw->bytes-=cw->offset;
186: else
187: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: count = %d < 0 in short subalocated\n", cw->bytes);
188: printk(KERN_ERR "DMSDOS: cluster %d read error\n",clusternr);
189: raw_brelse(sb,bh); return -1;
190: }
191: cw->bytes_in_clust=cw->bytes;
192: last_sect=0;
193: }
194: else
195: { /* long suballocation */
196: pp = &(bh->b_data[SECTOR_SIZE-8]);
197: cw->offset = CHS(pp) & (SECTOR_SIZE - 1);
198: cw->compressed = !(CHS(pp) & 0x8000);
199: if(CHS(pp)&0x4000)
200: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: suballocation not present, cluster %d\n",
201: clusternr);
202: raw_brelse(sb,bh); return -1;
203: };
204: cw->bytes=SECTOR_SIZE-cw->offset-8;
205: cw->bytes_in_clust+=cw->bytes-SECTOR_SIZE;
206: if (cw->bytes < 0) {
207: printk(KERN_ERR "DMSDOS: stac_cwalk_init: count = %d < 0 in long subalocated\n", cw->bytes);
208: printk(KERN_ERR "DMSDOS: cluster %d read error\n",clusternr);
209: raw_brelse(sb,bh); return -1;
210: }
211: };
212: raw_brelse(sb,bh);
213: break;
214:
215: case 0x9: /* ffff=001x, contradiction ??? */
216: case 0xb: /* ffff=011x, deleted 9 */
217: default:
218: printk(KERN_ERR "DMSDOS: stac_cwalk_init: unknown flags 0x%2x cluster %d\n",
219: mde.flags,clusternr);
220: return -1;
221: };
222:
223: /* if flg>=2 we are checking subalocated end of cluster */
224: /* because of we did not know if stacker can subalocate clusters
225: which are not in order we must check nonlinear
226: suballocation */
227: /* text above is question but now I know that stacker is able to do everything
228: nonlinear suballocation regulary exist */
229: if(last_sect&&(dblsb->s_cvf_version>=STAC4)&&(flg>=2))
230: { /* check for subalocated end of cluster */
231: /* 1) check start of next cluster for linear subalocation */
232: if(clusternr<dblsb->s_max_cluster)
233: { dbl_mdfat_value(sb,clusternr+1,NULL,&mde);
234: i=(mde.sector_minus_1+1)==last_sect;
235: if(i&&((mde.flags&0xA0)!=0xA0))
236: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: wrong cluster types for subalocation, cluster %d\n",
237: clusternr);
238: return -1;
239: };
240: } else i=0;
241: /* 2) check for nonlinear subalocation */
242: if((u=dbl_bitfat_value(sb,last_sect,NULL))==0) if(flg>=3)goto error1;
243: if((u>1)||(i))
244: { if((u<=1)&&(flg>=3))
245: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: suballocation error 1, cluster %d\n",
246: clusternr);
247: return -1;
248: };
249: if(!i)LOG_ALLOC("DMSDOS: stac_cwalk_init: nonlinear suballocation, cluster %d\n",
250: clusternr);
251: /* now we know that our cluster is subalocated, we must find
252: number of bytes in last sector of cluster */
253: bh=raw_bread(sb,last_sect);
254: if(bh==NULL)return -1;
255: pp=&(bh->b_data[SECTOR_SIZE-2]);
256: if(CHS(pp)!=0x1234)
257: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: suballocation error 2, cluster %d\n",
258: clusternr);
259: raw_brelse(sb,bh);
260: return -1;
261: };
262: pp = &(bh->b_data[SECTOR_SIZE-6]); /* begin of short suball. clust */
263: u = CHS(pp) & (SECTOR_SIZE - 1);
264: pp = &(bh->b_data[SECTOR_SIZE-8]); /* begin of long suball. clust */
265: v = CHS(pp) & (SECTOR_SIZE - 1);
266: raw_brelse(sb,bh);
267: /* u contains number of bytes of our cluster in last_sect */
268: if(v<u)
269: {
270: pp = &(bh->b_data[SECTOR_SIZE-6]);u = CHS(pp);
271: pp = &(bh->b_data[SECTOR_SIZE-8]);v = CHS(pp);
272: printk(KERN_ERR "DMSDOS: stac_cwalk_init: suballocation error 3, cluster %d, zerro offset 0x%X 0x%X\n",
273: clusternr,u,v);
274: return -1;
275: };
276: cw->bytes_in_last=u;
277: if(cw->sect_cnt>1)
278: cw->bytes_in_clust-=SECTOR_SIZE-u;
279: else if((i=cw->bytes+cw->offset-cw->bytes_in_last)>0)
280: { if((cw->bytes-=i)<=0)
281: { printk(KERN_ERR "DMSDOS: stac_cwalk_init: suballocation error 4, cluster %d\n",
282: clusternr);
283: return -1;
284: };
285: cw->bytes_in_clust-=i;
286: };
287: cw->bytes_in_last|=0x4000;
288: };
289: };
290:
291: if ((i=cw->bytes_in_clust-dblsb->s_sectperclust*SECTOR_SIZE)>0)
292: { cw->bytes_in_clust-=i;
293: if(!cw->bytes_in_last) cw->bytes_in_last=SECTOR_SIZE-i;
294: else if((cw->bytes_in_last-=i)<0x4000)
295: { error1:
296: printk(KERN_ERR "DMSDOS: stac_cwalk_init: bad bytes_in_cluster %d\n",
297: clusternr);
298: return -1;
299: };
300: };
301:
302: return cw->bytes_in_clust;
303: };
304:
305: /* returns in order all sectors of cluster */
306: /* in Stac_cwalk updates fields sect, offset and bytes */
307: int stac_cwalk_sector(Stac_cwalk *cw)
308: { if(!cw->sect)
309: { if(!cw->fcnt) return 0;
310: cw->fcnt--;
311: cw->flen--;
312: cw->sect=cw->start_sect;
313: }
314: else
315: { if(!cw->flen)
316: { if(!cw->fcnt) return 0;
317: cw->fcnt--;
318: if(cw->finfo==NULL)
319: { printk(KERN_ERR "DMSDOS: stac_cwalk_sector: finfo==NULL, cluster %d\n",
320: cw->clusternr);
321: return 0;
322: };
323: cw->sect=cw->finfo[0]+(cw->finfo[1]<<8)+((cw->finfo[3]&0x3f)<<16);
324: cw->flen=(cw->finfo[2]&0xf)+((cw->finfo[3]>>2)&0x30);
325: cw->finfo+=4;
326: }
327: else
328: { cw->sect++;
329: cw->flen--;
330: };
331: cw->offset=0;
332: if(!cw->flen&&!cw->fcnt&&cw->bytes_in_last)
333: cw->bytes=cw->bytes_in_last&(SECTOR_SIZE-1);
334: else cw->bytes=SECTOR_SIZE;
335: };
336: return cw->sect;
337: };
338:
339: void stac_cwalk_done(Stac_cwalk *cw)
340: {
341: if(cw->fbh!=NULL) raw_brelse(cw->sb,cw->fbh);
342: };
343:
344:
345: void stac_special_free(struct super_block*sb, int clusternr)
346: {
347: int val;
348: int sect;
349: Mdfat_entry newmde,dummy_mde;
350: Stac_cwalk cw;
351: Dblsb*dblsb=MSDOS_SB(sb)->private_data;
352:
353: val=stac_cwalk_init(&cw,sb,clusternr,0);
354: if(val<=0)
355: { if(val<0)
356: printk(KERN_ERR "DMSDOS: stac_special_free: alloc error in cluster %d\n", clusternr);
357: else
358: LOG_CLUST("DMSDOS: stac_special_free: already free cluster %d\n", clusternr);
359: return;
360: };
361: newmde.sector_minus_1=-1;
362: newmde.size_lo_minus_1=0;
363: newmde.size_hi_minus_1=0;
364: newmde.flags=0;
365:
366: dbl_mdfat_value(sb,clusternr,&newmde,&dummy_mde);
367: if((cw.flags&0xA0)==0xA0)
368: { /* mark part of suballocated sector as free */
369: struct buffer_head *bh;
370: bh=raw_bread(sb,cw.start_sect);
371: if(bh!=NULL)
372: { if(cw.start_len==1)
373: bh->b_data[SECTOR_SIZE-6+1] |= 0x40;
374: else
375: bh->b_data[SECTOR_SIZE-8+1] |= 0x40;
376: raw_mark_buffer_dirty(sb,bh,1);
377: raw_brelse(sb,bh);
378: }
379: }
380: /* free sectors from BITFAT */
381: while((sect=stac_cwalk_sector(&cw))>0)
382: {
383: val=dbl_bitfat_value(sb,sect,NULL);
384: if(val>0)
385: { --val;
386: dbl_bitfat_value(sb,sect,&val);
387: dblsb->s_full=0;
388: /* adapt s_free_sectors, -1 unknown */
389: /*if(val==0&&dblsb->s_free_sectors>=0) dblsb->s_free_sectors++;*/
390: /* Hi Pavel,
391: I have commented this out since free sector count is now
392: maintained in dbl_bitfat_value.
393: */
394: } else LOG_CLUST("DMSDOS: stac_special_free: sector not alocated\n");
395: }
396:
397: stac_cwalk_done(&cw);
398:
399: }
400:
401: /* replaces an existing cluster for stacker;
402: this unusual function must be called before rewriting any file cluster;
403: *** size must be known (encoded in mde) ***
404: it does nothing if called too often;
405: returns first sector nr
406: */
407:
408: int stac_replace_existing_cluster(struct super_block*sb, int cluster,
409: int near_sector,
410: Mdfat_entry*mde)
411: { Mdfat_entry old_mde,new_mde,dummy;
412: int i;
413: int newval;
414: int sector;
415: int old_sector;
416: int old_size;
417: int new_size;
418: Dblsb*dblsb=MSDOS_SB(sb)->private_data;
419:
420: lock_mdfat_alloc(dblsb);
421:
422: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster cluster=%d near_sector=%d\n",
423: cluster,near_sector);
424: dbl_mdfat_value(sb,cluster,NULL,&old_mde);
425: old_size=old_mde.size_lo_minus_1+1;
426: old_sector=old_mde.sector_minus_1+1;
427: new_size=mde->size_lo_minus_1+1;
428: if(old_mde.flags&2)
429: {
430: /* stacker routines always replace mdfat entry */
431: newval=0;
432: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster: freeing old sectors...\n");
433: stac_special_free(sb,cluster);
434: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster: freeing finished\n");
435: }
436: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster: call find_free_bitfat...\n");
437: sector=find_free_bitfat(sb,near_sector,new_size);
438: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster: find_free_bitfat returned %d\n",
439: sector);
440: if(sector<=0)
441: { if(old_mde.flags&2)
442: { /* Stacker routines don't have an undo list for now.
443: We cannot restore the state before. Sorry data are lost now. */
444: new_mde.sector_minus_1=0;
445: new_mde.size_lo_minus_1=0;
446: new_mde.size_hi_minus_1=0;
447: new_mde.flags=mde->flags=0;
448: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster: deleting mdfat entry...\n");
449: dbl_mdfat_value(sb,cluster,&new_mde,&dummy);
450: }
451: unlock_mdfat_alloc(dblsb);
452: return -ENOSPC; /* disk full */
453: }
454: /* check whether really free (bug supposed in find_free_bitfat) */
455: for(i=0;i<new_size;++i)
456: { if(dbl_bitfat_value(sb,sector+i,NULL))
457: { printk(KERN_EMERG "DMSDOS: find_free_bitfat returned sector %d size %d but they are not all free!\n",
458: sector,new_size);
459: unlock_mdfat_alloc(dblsb);
460: panic("DMSDOS: stac_replace_existing_cluster: This is a bug - reboot and check filesystem\n");
461: return -EIO;
462: }
463: }
464: newval=1;
465: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster: allocating in bitfat...\n");
466: for(i=0;i<new_size;++i)dbl_bitfat_value(sb,sector+i,&newval);
467:
468: new_mde.sector_minus_1=sector-1;
469: new_mde.size_lo_minus_1=mde->size_lo_minus_1;
470: new_mde.size_hi_minus_1=mde->size_hi_minus_1;
471: new_mde.flags=mde->flags|2;
472: LOG_ALLOC("DMSDOS: stac_replace_existing_cluster: writing mdfat...\n");
473: dbl_mdfat_value(sb,cluster,&new_mde,&dummy);
474: unlock_mdfat_alloc(dblsb);
475: return sector; /* okay */
476: }
477:
478: #endif /* DMSDOS_CONFIG_STAC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.